Hata Ne Anlama Geliyor?
Rust, bellek güvenliği sağlamak için bir takım sıkı kurallar koyar. Bu kurallardan en önemlilerinden biri, bir değişkenin aynı anda hem immutable (değiştirilemez) hem de mutable (değiştirilebilir) olarak ödünç alınmamasıdır. Bu hata genellikle şöyle bir durumda ortaya çıkar:
Diyelim ki bir değişkeni okuma işlemi yapmak istiyorsunuz (immutable borrow) ama aynı anda o değişkene yazmak da istiyorsunuz (mutable borrow). Rust, bu tür durumları engelleyerek sizin daha güvenli ve hatasız bir kod yazmanızı sağlar.
Peki bu hatayı nasıl alırız? İşte basit bir örnek:
fn main() {
let mut x = 5;
let y = &x; // Immutable borrow
let z = &x; // Immutable borrow (bu satır sorun yaratır)
println!("y: {}, z: {}", y, z); // Hata! Aynı anda iki immutable borrows
}
Yukarıdaki örnekte, `x` değişkeni hem `y` hem de `z` için immutable olarak ödünç alındı. Ancak Rust, aynı anda iki immutable ödünç alma işlemine izin vermez. Bu yüzden "Cannot borrow immutable twice" hatasını alırsınız.
Hatanın Çözümü
Peki, bu hatayı nasıl düzeltebiliriz? Çözüm aslında oldukça basit. Rust, aynı anda sadece bir ödünç alma işlemine izin verir. Bunun için iki yaygın çözüm yolu vardır:
1. Ödünç Alma Süresini Kısaltın
Bir değişkene yapılacak işlemi bir blok içinde sınırlayarak, ödünç alma işlemini hızlıca tamamlayabiliriz. Örneğin, `y` ve `z`’yi aynı anda kullanmak yerine, her birine ayrı ayrı erişebilirsiniz.
fn main() {
let mut x = 5;
let y = &x; // Immutable borrow
println!("y: {}", y); // y kullanıldı
let z = &x; // Immutable borrow tekrar yapıldı
println!("z: {}", z); // z kullanıldı
}
Bu şekilde, `y` ve `z` birbirini takip eden iki farklı ödünç alma işlemine dönüştü. Artık aynı anda iki değişkeni ödünç almadığınız için hata almazsınız.
2. Değişkeni Mutable Olarak Ödünç Alın
Eğer değişkene yazmanız gerekiyorsa, onu mutable olarak ödünç alabilirsiniz. Ancak bu durumda, değişkeni bir kez mutable olarak ödünç aldıktan sonra, başka bir işlem yapmadan önce değişkenle ilgili işlemin bitmiş olması gerekir.
fn main() {
let mut x = 5;
let y = &x; // Immutable borrow
println!("y: {}", y); // Immutable borrow kullanıldı
let z = &mut x; // Mutable borrow
*z = 10; // Değeri değiştirdik
println!("z: {}", z); // Mutable borrow kullanıldı
}
Bu örnekte, önce `x`'i immutable olarak ödünç alıyoruz, sonra mutable olarak ödünç alıp değerini değiştiriyoruz. Rust, bir değişkenin mutable olarak ödünç alındığı anda, diğer borrows işlemlerini engeller.
Sonuç olarak
"Cannot borrow immutable twice" hatası, Rust'ın bellek güvenliğini sağlamak amacıyla koyduğu kurallardan biridir ve her yeni Rust geliştiricisinin karşılaşabileceği bir hatadır. Bu hata, genellikle aynı değişkene birden fazla immutable referans almak istendiğinde ortaya çıkar. Rust, bu tür hataları engelleyerek daha güvenli bir yazılım geliştirme deneyimi sunar.
Unutmayın, her zaman bir değişkene sadece bir ödünç alma işlemi yapılabilir. Eğer immutable ve mutable borrows arasında bir tercih yapmanız gerekiyorsa, bunu doğru yönetmek, sağlıklı ve güvenli kod yazmanıza yardımcı olacaktır.
