Generic Metotlar

Coddy'nin Rust Journey'sinin Nesne Yönelimli Programlama bölümünün bir parçası. Ders 25 / 61.

Genel bir yapı herhangi bir türü tutabilir, ancak verileriyle etkileşim kuracak yöntemler olmadan pek kullanışlı değildir. Genel bir yapı için yöntemler tanımlamak üzere impl bloğunda özel bir sözdizimi kullanman gerekir.

Anahtar, genel parametreyi doğrudan impl üzerinde bildirmektir:

struct Wrapper<T> {
    value: T,
}

impl<T> Wrapper<T> {
    fn get(&self) -> &T {
        &self.value
    }
}

Wrapper<T> öncesindeki impl<T> ifadesine dikkat et. Bu, Rust'a T'nin tüm uygulama bloğu için genel bir tür parametresi olduğunu bildirir. Bu bildirim olmadan Rust, T adlı somut bir tür arar ve bulamaz.

get metodu, sarmalayıcının tuttuğu tür ne olursa olsun o türe ait bir referans olan &T değerini döndürür. Bu, T bir tamsayı, bir metin dizisi ya da başka herhangi bir tür olduğunda da çalışır:

let num_wrapper = Wrapper { value: 100 };
let text_wrapper = Wrapper { value: "Rust" };

println!("{}", num_wrapper.get());  // 100
println!("{}", text_wrapper.get()); // Rust

Aynı yöntem tanımı her ikisi için de işe yarar, çünkü genel T derleme zamanında her somut türe uyum sağlar.

Görev

Kolay

Genel kapsayıcını yöntemlerle genişletelim! Her türü tutabilen ve içeriğiyle etkileşim kurmak için yöntemler sağlayan bir Box yapısı oluşturacaksın (Rust'ın standart Box yapısıyla karıştırma).

Kodunu iki dosyaya ayıracaksın:

mybox.rs: T türünde özel bir contents alanına sahip, MyBox<T> adlı genel ve herkese açık bir yapı tanımla. Bu yapı için yöntemler uygula:
- Verilen değerle yeni bir MyBox oluşturan bir new ilişkili işlevi
- İçeriğe bir referans döndüren bir peek yöntemi (&self kullanarak)
- Yeni bir değer alan ve mevcut içeriğin yerine koyan bir replace yöntemi (&mut self kullanarak)
main.rs: Modülünü içe aktar ve genel yöntemlerin farklı türlerle çalıştığını göster. Kutular oluşturacak, içeriklerine bakacak ve yöntemlerin çalışmasını göstermek için değerleri değiştireceksin.

Genel bir yapıya yöntem uygulamak için gereken temel sözdizimini unutma: Rust'a T türünün tüm uygulama bloğu için genel bir parametre olduğunu belirtmek üzere MyBox<T> ifadesinden önce impl<T> yazmalısın.

Ana dosyanda MyBox yapısını şu şekilde göster:

Tamsayıyla bir kutu oluştur (ilk girdi, i32 olarak ayrıştırılır)
İçeriğine bak ve değeri yazdır
İçeriği yeni bir tamsayıyla değiştir (ikinci girdi, i32 olarak ayrıştırılır)
Güncellenen değeri göstermek için yeniden içeriğine bak
Dizeyle ikinci bir kutu oluştur (üçüncü girdi)
Dize kutusunun içeriğine bak

Çıktın şu biçimde olmalı:

Integer box contains: {value}
After replace: {value}
String box contains: {value}

Örneğin, girdiler 10, 25 ve Rust olduğunda:

Integer box contains: 10
After replace: 25
String box contains: Rust

Üç girdi alacaksın: bir başlangıç tamsayısı, bir değiştirme tamsayısı ve bir dize değeri.

Kendin dene

mod mybox;

use mybox::MyBox;

fn main() {
    // Girdileri oku
    let mut input1 = String::new();
    std::io::stdin().read_line(&mut input1).expect("Failed to read line");
    let initial_int: i32 = input1.trim().parse().expect("Invalid integer");

    let mut input2 = String::new();
    std::io::stdin().read_line(&mut input2).expect("Failed to read line");
    let replacement_int: i32 = input2.trim().parse().expect("Invalid integer");

    let mut input3 = String::new();
    std::io::stdin().read_line(&mut input3).expect("Failed to read line");
    let string_value = input3.trim().to_string();

    // TODO: Başlangıçtaki tam sayı ile bir MyBox oluştur
    
    // TODO: İçeriğine göz at ve şunu yazdır: "Integer box contains: {value}"
    
    // TODO: İçeriği yeni tam sayı ile değiştir
    
    // TODO: İçeriğine tekrar göz at ve şunu yazdır: "After replace: {value}"
    
    // TODO: Dizge değeri ile ikinci bir MyBox oluştur
    
    // TODO: Dizge kutusunun içeriğine göz at ve şunu yazdır: "String box contains: {value}"
}