Rust, son yıllarda geliştiricilerin gönlünü fethetmiş bir dil. Güçlü bellek güvenliği özellikleri, yüksek performansı ve modern sözdizimi ile ön plana çıkıyor. Ancak, Rust'ın size sunduğu bu güçlü özelliklerin bir bedeli var: borçlanma kuralları. Bu kurallar bazen başımızı derde sokabiliyor. İşte bunlardan biri de "Cannot borrow immutable twice" hatası.
Şimdi, gelin bu hatayı nasıl çözeceğimizi bir hikaye üzerinden anlatalım.
Rust'ın Garip Kurallarıyla Tanışma
Bir gün, yeni bir Rust projesi üzerinde çalışırken, basit bir işlev yazmak için kodu açtım. İşin içine biraz hesaplama ve veri okuma karıştırdım. Ama bir anda, Rust'ın beklenmedik bir şekilde hata verdiğini gördüm. Hata mesajı şöyleydi:
error[E0502]: cannot borrow `x` as immutable because it is also borrowed as mutable
Buharlaştım! Ne demek bu şimdi? Ne yanlış gitti? İşte burada Rust'ın *borrow checker* denen o akıllı sistemi devreye giriyor. Bu sistem, değişkenlere nasıl erişildiğine dair çok sıkı kurallar koyuyor. Eğer bir değişkeni birden fazla şekilde aynı anda borçlanmaya çalışırsanız, Rust size bu hatayı gösteriyor.
Hata Neden Olur?
Rust, her değişkenin bir anda yalnızca bir borçlanmaya sahip olmasını ister. Yani ya değişkeni *değiştirilebilir (mutable)* bir referansla, ya da *değiştirilemez (immutable)* bir referansla ödünç alabilirsiniz. Ama bir değişkeni birden fazla immutable referansla borçlanmaya çalışırsanız, bu hatayla karşılaşırsınız.
Bunun bir örneğini kodla gösterelim:
fn main() {
let x = 10;
let y = &x;
let z = &x; // Burada iki immutable referans alınıyor
println!("y: {}, z: {}", y, z);
}
Bu kodda, `x` değişkenine iki farklı immutable referans `y` ve `z` ile başvuruyoruz. Rust bunu engeller çünkü bir değişkene birden fazla immutable referans verilmesi bellek güvenliği açısından tehlikeli olabilir. Bu yüzden, "Cannot borrow immutable twice" hatası alırsınız.
Hata Nasıl Çözülür?
Rust'ta bu hatayı çözmek için yapabileceğiniz birkaç şey var. Hadi birlikte inceleyelim.
# 1. Immutable Referansları Sınırlayın
İlk çözüm, her zaman yalnızca bir immutable referans kullanmaktır. Yani, bir değişkeni birden fazla kez immutable olarak borçlamadan önce, borçların sonlandırılmasını bekleyebilirsiniz. Örneğin:
fn main() {
let x = 10;
let y = &x;
println!("y: {}", y);
let z = &x; // y referansının sona ermesinden sonra z'yi borç alabilirim
println!("z: {}", z);
}
Bu şekilde, bir referans kullanıldıktan sonra başka bir referans alınabilir.
# 2. Mutable Referans Kullanmak
Eğer gerçekten bir değişken üzerinde birkaç işlem yapmanız gerekiyorsa, mutable bir referans kullanmayı düşünebilirsiniz. Böylece değişkeni değiştirebilir ve borçlanmaları daha esnek hale getirebilirsiniz. Örnek:
fn main() {
let mut x = 10;
let y = &mut x; // mutable referans
*y += 5; // mutable referans ile değeri değiştirebiliriz
println!("y: {}", y);
}
Burada, `x` değişkenini sadece bir mutable referans ile borç alıyoruz. Ancak dikkat edin, Rust bir mutable referansı aynı anda başka bir yerde kullanmanıza izin vermez. Yani `y`'yi kullandıktan sonra başka bir yerden `x`'i değiştirmeniz engellenir.
Hata ve Rust'ın Borçlanma Kuralları
Rust'ın bu kuralları kulağa zorlayıcı gibi gelse de, aslında size güçlü bir güvenlik sağlıyor. Özellikle çok büyük ve karmaşık projelerde, bellek hatalarını önlemenin ne kadar önemli olduğunu hepimiz biliyoruz. Bu kurallar sayesinde, hataları derleme aşamasında yakalarız ve çalışma zamanında bellek sızıntısı ya da data race gibi sorunlarla karşılaşmayız.
Sonuç
"Cannot borrow immutable twice" hatası, Rust'ın bellek güvenliği sağlamak adına koyduğu sıkı kuralların bir sonucudur. Bu hata, aslında programınızın güvenli bir şekilde çalışması için iyi bir işarettir. Eğer bu hatayı alıyorsanız, kodunuzun mantığını gözden geçirmeli ve değişkenleri nasıl borçlandığınıza dikkat etmelisiniz.
Rust'la çalışırken bu tür hatalarla karşılaşmak doğal. Ancak doğru anlayış ve dikkatli bir yaklaşım sayesinde bu hataları çözebilir, daha sağlam ve güvenli kodlar yazabilirsiniz.
