Generic Struct'lar

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

Şimdiye kadar oluşturduğun her yapının belirli, somut türlere sahip alanları oldu. Bir Pet yapısının String türünde bir adı, bir Rectangle yapısının f64 türünde boyutları var. Peki herhangi bir veri türünü tutabilen bir yapı oluşturmak istersen ne olacak?

Jenerikler işte burada devreye girer. Jenerikler, birden çok türle çalışan esnek ve yeniden kullanılabilir kod yazmanı sağlar. Belirli bir türü sabit olarak kodlamak yerine, genellikle T olan ve yapıyı kullandığında somut bir türle değiştirilen bir yer tutucu kullanırsın.

Herhangi bir türü tutabilen basit bir sarmalayıcı yapı aşağıda verilmiştir:

struct Wrapper<T> {
    value: T,
}

Yapı adından sonraki <T>, genel bir tür parametresi bildirir. Yapının içinde T, gerçekte kullanacağınız herhangi bir türün yer tutucusu olarak işlev görür. Bir örnek oluşturduğunuzda Rust somut türü çıkarır:

let int_wrapper = Wrapper { value: 42 };        // T i32'dir
let float_wrapper = Wrapper { value: 3.14 };    // T f64'tür
let text_wrapper = Wrapper { value: "hello" };  // T &str'dir

Bunların her biri farklı bir somut türdür: Wrapper<i32>, Wrapper<f64> ve Wrapper<&str>; ancak hepsi aynı yapı tanımını paylaşır. Bu, temelde aynı işi yapan ayrı IntWrapper, FloatWrapper ve StringWrapper yapıları yazma gereğini ortadan kaldırır.

T harfi yalnızca bir gelenektir ("Tür" ifadesinin kısaltması). Geçerli herhangi bir tanımlayıcıyı kullanabilirsin, ancak T, Rust'ta ve jeneriklere sahip diğer birçok dilde standarttır.

Görev

Kolay

Her türde değeri tutabilen genel amaçlı bir kapsayıcı oluşturalım! Generic türlerin kodunuzu nasıl esnek ve yeniden kullanılabilir hâle getirdiğini gösterecek bir Container yapısı oluşturacaksınız.

Kodunuzu iki dosyaya ayıracaksınız:

container.rs: Tek bir genel erişimli Container<T> alanına sahip, item türünde ve T adlı genel erişimli bir yapı tanımlayın. Bu kapsayıcı; tamsayıları, kayan noktalı sayıları, dizeleri veya başka herhangi bir şeyi tutabilmelidir.
main.rs: Kapsayıcı modülünüzü içe aktarın ve farklı türlerde veriler tutan kapsayıcılar oluşturarak esnekliğini gösterin. Üç kapsayıcı oluşturacak ve her birinin tuttuğu değeri görüntüleyeceksiniz.

Ana dosyanızda aşağıdaki kapsayıcıları oluşturun:

Tamsayı değeri tutan bir kapsayıcı (ilk girdi i32 olarak ayrıştırılır)
Kayan noktalı değer tutan bir kapsayıcı (ikinci girdi f64 olarak ayrıştırılır)
Bir dize tutan kapsayıcı (üçüncü girdi String olarak tutulur)

Çıktınız, her kapsayıcının içeriğini aşağıdaki biçimde görüntülemelidir:

Integer container: {value}
Float container: {value}
String container: {value}

Örneğin, 42, 3.14 ve hello girdileriyle:

Integer container: 42
Float container: 3.14
String container: hello

Aynı Container<T> tanımının üç farklı türün tamamında çalıştığına dikkat edin: generic türlerin gücü budur!

Üç girdi alacaksınız: bir tamsayı değeri, bir kayan noktalı değer ve bir dize değeri.

Kendin dene

mod container;

use container::Container;

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

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

    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: Create three containers using Container<T>
    // 1. An integer container holding int_value
    // 2. A float container holding float_value
    // 3. A string container holding string_value

    // TODO: Her konteynerin içeriğini gerekli formatta yazdır
    // Integer container: {value}
    // Float container: {value}
    // String container: {value}
}