Rust dilinde program yazarken karşımıza çıkan en yaygın hatalardan biri şüphesiz "Cannot borrow immutable twice" hatasıdır. Bu hata, özellikle Rust'un ödüllü *borrow checker* (ödünç alma denetleyicisi) tarafından çok sık kontrol edilen bir durumdur. Rust'un sahiplik ve ödünç alma sisteminin, bellek güvenliğini sağlamadaki rolünü hepimiz biliyoruz. Ancak bazen bu kurallar, bir hata ile karşılaşmamıza yol açabilir. Peki, bu hata tam olarak ne anlama geliyor ve nasıl çözülebilir?
Rust'un Borrowing Sistemi
Rust'ta değişkenler, sahiplik (ownership) ve ödünç alma (borrowing) gibi katı kurallara tabidir. Bu kurallar, bellek güvenliğini garanti altına alır. Ancak bu kurallar bazen ilk bakışta karmaşık ve anlaşılması zor olabilir.
Örneğin, Rust'ta bir değeri immutable (değiştirilemez) olarak ödünç alırsanız, bu değerin sadece okunmasına izin verilir. Aynı anda bir değeri birden fazla kez immutable olarak ödünç alamazsınız. İşte "Cannot borrow immutable twice" hatası, bu kuralların ihlali durumunda karşımıza çıkar.
Hata Mesajı: "Cannot Borrow Immutable Twice"
Bu hatayı genellikle şu durumda görürüz:
```rust
fn main() {
let x = 5;
let y = &x; // İlk immutable borçlanma
let z = &x; // İkinci immutable borçlanma, burada hata oluşur
println!("y: {}, z: {}", y, z);
}
```
Yukarıdaki kodda, `x` değişkeni iki kez immutable olarak ödünç alınıyor. Rust, aynı anda bir değişkenin iki kez immutable olarak ödünç alınmasına izin vermez, çünkü bu, veri yarışlarına ve bellek hatalarına yol açabilir. Bu durumda aşağıdaki hata mesajını alırsınız:
```
error[E0502]: cannot borrow `x` as immutable because it is also borrowed as immutable
```
Burada, Rust'un borç verme sistemi devreye girer ve siz iki kez aynı veriyi ödünç almaya çalıştığınız için hata verir.
Hata Nasıl Çözülür?
Bu hatayı çözmek için birkaç farklı yaklaşımımız olabilir. En yaygın çözüm, aynı anda birden fazla immutable ödünç alma yerine, bir ödünç alma işleminden sonra diğerine geçmektir. İşte çözümün birkaç yolu:
# 1. Veriyi Tek Bir Defa Immutable Olarak Ödünç Almak
İlk olarak, veriyi yalnızca bir kez immutable olarak ödünç almayı deneyebilirsiniz:
```rust
fn main() {
let x = 5;
let y = &x; // İlk immutable borçlanma
println!("y: {}", y);
}
```
Burada sadece bir `&x` borçlanması olduğu için hiçbir hata oluşmaz.
# 2. Veriyi Değiştirilebilir Olarak Ödünç Almak
Eğer veriyi aynı anda birden fazla referansla kullanmanız gerekiyorsa, o zaman değiştirilebilir bir borç (mutable borrow) kullanabilirsiniz. Ancak mutable borrow, yalnızca bir defa yapılabilir:
```rust
fn main() {
let mut x = 5;
let y = &mut x; // İlk mutable borçlanma
*y += 1; // x'i değiştirme
println!("y: {}", y);
}
```
Bu şekilde bir değişkenin yalnızca bir mutable referansı olabilir. Eğer aynı anda birden fazla referansa ihtiyacınız varsa, o zaman veri üzerinde *mutable* işlemler yapmamanız gerekir.
# 3. Borçların Sürelerini Kontrol Etmek
Rust, referansların yaşam süresini sıkı bir şekilde takip eder. Eğer bir değişkeni birden fazla kez immutable olarak ödünç almak istiyorsanız, referansların yaşam süresini iyi yönetmeniz gerekir. Bir referansın yaşam süresi bittiğinde, bir diğeri alınabilir.
Sonuç
Rust'un "Cannot borrow immutable twice" hatası, ilk başta karmaşık gibi görünse de aslında bellek güvenliğini sağlamanın bir yolu olarak oldukça güçlüdür. Rust'un ödünç alma ve sahiplik kurallarını anlamak ve bu kurallara göre kod yazmak, daha güvenli ve daha hatasız uygulamalar yazmanıza yardımcı olacaktır. Bu hatayı alırsanız, genellikle sadece ödünç alma işlemlerinizi tek bir defa yapmak ya da mutable borç kullanmak yeterli olacaktır.
Rust ile çalışırken, dilin sunduğu güvenlik özelliklerinden yararlanarak programınızın hem güvenli hem de verimli olmasını sağlamak oldukça önemlidir. Unutmayın, Rust'ın borrow checker her zaman arkanızda olacak!
