Rust’ta "Ownership" ve "Borrowing" Nedir?
Rust'ın en güçlü özelliklerinden biri, bellek güvenliğini sağlamak için geliştirdiği *ownership* (sahiplik) modelidir. Bu model, veri üzerinde kimin ne zaman erişim hakkına sahip olduğunu net bir şekilde tanımlar. "Ownership" sayesinde, bellek sızıntıları ve diğer bellek hataları ortadan kaldırılabilir.
Ancak burada bir durum var ki, bu kuralların doğru bir şekilde anlaşılması gerekiyor. Örneğin, bir değişkenin yalnızca bir sahibi olabilir. Eğer bir değişken başka bir değişkene ödünç verilirse (borrowing), sahiplik hala ilk değişkende kalır, ancak ödünç alan değişken sadece okuma (immutable borrow) veya yazma (mutable borrow) izni alabilir.
"Ownership Borrowing Error" Nedir?
Rust'ta "Ownership Borrowing Error", genellikle ödünç alma kuralları ihlal edildiğinde ortaya çıkar. Bu tür hatalar genellikle aşağıdaki senaryolarda görülür:
1. Aynı anda hem *mutable* (değiştirilebilir) hem de *immutable* (değiştirilemez) ödünç alma yapılması.
2. Bir ödünç alınan değişkenin, ödünç veren değişkenin kapsamı bitmeden kullanılmaya çalışılması.
Bu hata, derleyici tarafından oldukça sıkı bir şekilde kontrol edilir, çünkü bellek güvenliği her şeyden önce gelir. Aşağıda bu tür bir hataya örnek bir kodu inceleyeceğiz.
Örnek Kod: "Ownership Borrowing Error"
// Rust'ta Ownership Borrowing Error örneği
fn main() {
let mut s1 = String::from("Merhaba");
// s1'den bir değiştirilemez (immutable) ödünç alıyoruz
let s2 = &s1;
// Aynı anda s1 üzerinde değişiklik yapmak istiyoruz
s1.push_str(", Dünya!"); // Hata: s1 zaten ödünç verilmiş durumda
}
Hata Neden Oluşuyor?
Bu hatanın nedeni, aynı anda bir değişkenin hem *immutable* hem de *mutable* ödünç verilmesi. Rust, aynı anda hem okuma hem de yazma izinlerine sahip olmanıza izin vermez. Bu, verinin tutarsız bir duruma düşmesini engellemek için alınan önemli bir güvenlik önlemidir.
Rust'ta bir değişkene *mutable* ödünç verme işlemi, diğer tüm ödünç almaların sona ermesini gerektirir. Bu, bellek hatalarına yol açabilecek durumların önüne geçmek için gereklidir.
Nasıl Çözülür?
Bu hatanın çözülmesi için, bir değişken üzerinde aynı anda hem *mutable* hem de *immutable* ödünç almamamız gerekir. İki farklı yaklaşım kullanarak bu hatayı düzeltebiliriz:
1. Immutable Ödünç ve Mutable Ödünç Arasında Ayrım Yapmak:
Değişkenin yalnızca bir tür ödünç alındığından emin olun. Aşağıdaki gibi, değişkenin mutable ödünç alma işleminden önce, immutable ödünç alma işlemini sonlandırabiliriz.
// Rust'ta doğru kullanım örneği
fn main() {
let mut s1 = String::from("Merhaba");
// İlk olarak s1'e immutable ödünç alıyoruz
let s2 = &s1;
println!("{}", s2); // Bu güvenli
// Sonra s1 üzerinde değişiklik yapıyoruz
s1.push_str(", Dünya!"); // Bu da güvenli çünkü s2'nin kapsamı bitti
}
2. Değişkenin Sahipliğini Taşımak (Ownership Transfer):
Eğer değiştirme işlemi yapmanız gerekiyorsa, değişkenin sahipliğini tamamen başka bir değişkene verebilirsiniz.
// Sahiplik transferi örneği
fn main() {
let mut s1 = String::from("Merhaba");
// s1'in sahipliğini s2'ye veriyoruz
let s2 = s1; // s1 artık geçersiz, sahiplik s2'ye geçti
s2.push_str(", Dünya!"); // Bu güvenli çünkü s2 artık s1'in sahibi
}
Rust'ta Hata Yönetimi ve Güvenlik
Rust'taki "Ownership Borrowing Error" hataları, başlangıçta karmaşık gibi görünebilir, ancak aslında dilin güçlü bellek güvenliği garantilerinin bir parçasıdır. Bu hatalar, veri yarışlarını ve bellek sızıntılarını önlemek için derleyici tarafından çok katı bir şekilde kontrol edilir. Bu, Rust'ın güçlü özelliklerinden biri olan bellek güvenliğini sağlamak için bir avantajdır.
Rust, bellekle ilgili sorunlardan kaçınırken aynı zamanda verimli bir şekilde çalışabilmeniz için size güçlü bir araç seti sunar. Bu hatayı anlamak ve çözmek, dilin öğrenilmesi sürecinde çok değerli bir adımdır.
