Hata Mesajı ve Anlamı
Bu hata mesajı, Rust’ın "borrowing" kurallarının bir sonucu olarak karşımıza çıkar. Rust, bellek güvenliğini sağlamak için, bir değeri aynı anda yalnızca bir kez değiştirilebilir veya değiştirilemez (immutable) olarak borçlanmanıza izin verir. Bu, veri yarışlarının (data races) önüne geçmek için oldukça önemli.
Ancak, bazı durumlarda, aynı veri üzerinde birden fazla immutable borrow yapmaya çalıştığınızda bu hata ile karşılaşırsınız. Rust, değişkenin birden fazla kez immutable olarak referans alınmasına izin vermez çünkü bu, bellek üzerinde tutarsızlıklara yol açabilir.
Örnek Üzerinden Anlayalım
Daha iyi anlamanız için basit bir örnek üzerinden gidelim:
fn main() {
let s = String::from("Merhaba, Rust!");
let s_ref1 = &s; // İlk immutable borç
let s_ref2 = &s; // İkinci immutable borç
println!("{}", s_ref1);
println!("{}", s_ref2);
}
Bu kodu çalıştırdığınızda, aşağıdaki gibi bir hata alırsınız:
```
error[E0502]: cannot borrow `s` as immutable more than once at a time
```
Bu hata, `s` değişkenine iki kez immutable olarak borç almayı denediğiniz için meydana gelir. Rust, bunun bellek güvenliği açısından tehlikeli olabileceğini düşünüyor ve bu yüzden ikinci borcu kabul etmiyor.
Nasıl Çözülür?
Bu hatayı çözmenin birkaç yolu vardır. İlk çözüm, aynı veriyi aynı anda birden fazla kez borç almak yerine, her referansı kullandıktan sonra borcu sonlandırmaktır. Rust, bir borç geçerli olduğu sürece veri üzerinde değişiklik yapmanızı engeller. Ancak, borcun geçerli olmadığı bir anda yeni borçlar alabilirsiniz.
Örneğin, yukarıdaki örneği şöyle düzeltebiliriz:
fn main() {
let s = String::from("Merhaba, Rust!");
let s_ref1 = &s; // İlk immutable borç
println!("{}", s_ref1); // Borcu kullandık
let s_ref2 = &s; // İkinci immutable borç
println!("{}", s_ref2); // Borcu kullandık
}
Bu kod, artık hatasız çalışacaktır çünkü her iki referans da birbirinden bağımsız bir şekilde kullanılıyor.
Diğer Bir Çözüm Yolu: Dönüşüm Kullanmak
Bir başka çözüm yolu ise borrowing yerine veriyi bir değişkene kopyalamak olabilir. Kopyalama, Rust’ın bellek güvenliği kuralları çerçevesinde sorun yaratmaz çünkü her bir kopya bağımsız bir veri olur.
Örneğin:
fn main() {
let s = String::from("Merhaba, Rust!");
let s_copy1 = s.clone(); // Veriyi kopyala
let s_copy2 = s.clone(); // Bir başka kopya al
println!("{}", s_copy1);
println!("{}", s_copy2);
}
Burada, `clone()` fonksiyonu ile verinin kopyalarını alarak, aynı veri üzerinde birden fazla immutable borç almış gibi görünür, ancak aslında her bir değişken bağımsızdır. Bu yöntemle Rust, bellek üzerinde herhangi bir çakışma görmediği için hata vermez.
Sonuç: "Cannot Borrow Immutable Twice" Hatası ile İlgili Öğrendiklerimiz
Rust’ın borçlanma kuralları, dilin bellek güvenliğini sağlamak için çok güçlüdür. Bu kurallara dikkat ederek yazdığınız kodun güvenliğini artırabilirsiniz.
Eğer "Cannot borrow immutable twice" hatası ile karşılaşırsanız, veri üzerinde aynı anda birden fazla immutable referans almamaya dikkat etmelisiniz. Bunun yerine, borçları sırayla kullanarak ya da veriyi kopyalayarak bu hatadan kaçınabilirsiniz. Bu basit ama etkili kurallar, programınızın güvenli ve verimli olmasını sağlar.
Unutmayın, Rust size hatalarla dolu bir yolculuk sunuyor, ama aynı zamanda her hatadan çok şey öğrenebilirsiniz. Şimdi bu bilgileri kullanarak bir sonraki projenizde hata almadan özgürce kod yazabilirsiniz!
