Çoklu Generic Türler

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

Bazen tek bir genel parametre yeterli değildir. Ya iki değer tutan ve bu değerlerin farklı türlerde olabileceği bir yapıya ihtiyacın varsa? Rust, birden fazla genel parametreyi virgüllerle ayırarak kullanmana olanak tanır.

İşte potansiyel olarak farklı türlerde iki değer tutan bir Pair yapısı:

struct Pair<T, U> {
    first: T,
    second: U,
}

<T, U> iki bağımsız tür parametresi bildirir. T ve U aynı tür olabilir veya tamamen farklı türler olabilir: bir örnek oluştururken seçim sana aittir:

let both_ints = Pair { first: 10, second: 20 };       // T=i32, U=i32
let mixed = Pair { first: "hello", second: 3.14 };    // T=&str, U=f64
let reversed = Pair { first: 100, second: "world" }; // T=i32, U=&str

Yöntemleri uygularken tüm genel parametreleri impl bloğunda bildirirsin:

impl<T, U> Pair<T, U> {
    fn get_first(&self) -> &T {
        &self.first
    }

    fn get_second(&self) -> &U {
        &self.second
    }
}

Bu kalıp, key-value çifti, farklı sayısal türlerde koordinatlar veya metadata ile eşleştirilmiş bir sonuç gibi, birbiriyle ilişkili ancak potansiyel olarak farklı iki veri parçasını ilişkilendirmeniz gerektiğinde yaygındır.

Görev

Kolay

Birden fazla genel türün gücünü gösteren bir anahtar-değer depolama sistemi oluşturalım! Herhangi iki türü eşleştirebilen bir KeyValue yapısı oluşturacaksınız; bu yapı etiketleri verilerle, kimlikleri nesnelerle veya başka herhangi bir kombinasyonu ilişkilendirmek için mükemmeldir.

Kodunuzu iki dosyada düzenleyeceksiniz:

keyvalue.rs: İki özel alana sahip, KeyValue<K, V> adlı genel bir yapı tanımlayın: key türünde K ve value türünde V. Bu yapıyla çalışmak için yöntemler uygulayın:
- Bir anahtar ve değerden new oluşturan KeyValue ilişkili işlevi
- Anahtara bir başvuru döndüren key yöntemi
- Değere bir başvuru döndüren value yöntemi
- Geçerli değeri yeni bir değerle değiştiren set_value yöntemi
main.rs: Modülünüzü dahil edin ve aynı yapı tanımının farklı tür kombinasyonlarıyla nasıl çalıştığını gösterin. Birden fazla genel türün esnekliğini göstermek için farklı türlerde anahtar-değer çiftleri oluşturacaksınız.

Ana dosyanızda aşağıdaki anahtar-değer çiftlerini oluşturun ve bunlarla çalışın:

Dize anahtarlı ve tamsayı değerli bir çift (ilk girdi anahtar, ikinci girdi i32 olarak ayrıştırılan değer)
Anahtarı ve değeri yazdırın
Değeri yeni bir tamsayıyla güncelleyin (üçüncü girdi i32 olarak ayrıştırılır)
Güncellenmiş değeri yazdırın
Tamsayı anahtarlı ve dize değerli ikinci bir çift oluşturun (dördüncü girdi anahtar olarak i32 şeklinde ayrıştırılır, beşinci girdi değer olarak kullanılır)
Bu çiftin anahtarını ve değerini yazdırın

Çıktınız şu biçimi izlemelidir:

Key: {key}, Value: {value}
Updated value: {value}
Key: {key}, Value: {value}

Örneğin, girdiler name, 42, 100, 7 ve lucky olduğunda:

Key: name, Value: 42
Updated value: 100
Key: 7, Value: lucky

İlk çiftin KeyValue<String, i32> kullandığına, ikinci çiftin ise KeyValue<i32, String> kullandığına dikkat edin: aynı yapı, farklı tür kombinasyonları!

Beş girdi alacaksınız: bir dize anahtar, bir tamsayı değer, bir değiştirme tamsayısı, bir tamsayı anahtar ve bir dize değer.

Kendin dene

mod keyvalue;

use keyvalue::KeyValue;

fn main() {
    // Beş girdi oku
    let mut input1 = String::new();
    std::io::stdin().read_line(&mut input1).expect("Failed to read line");
    let string_key = input1.trim().to_string();

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

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

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

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

    // TODO: string_key ve int_value kullanarak bir KeyValue<String, i32> çifti oluştur

    // TODO: Anahtarı ve değeri şu formatta yazdır: "Key: {key}, Value: {value}"

    // TODO: set_value kullanarak değeri replacement_int ile güncelle

    // TODO: Print the updated value in format: "Updated value: {value}"

    // TODO: int_key ve string_value kullanarak bir KeyValue<i32, String> çifti oluştur

    // TODO: Bu çiftin anahtarını ve değerini şu formatta yazdır: "Key: {key}, Value: {value}"
}