Beberapa Blok Implementasi

Termasuk bagian Pemrograman Berorientasi Objek dalam perjalanan Rust di Coddy. Pelajaran 5 dari 61.

Rust memungkinkan kamu membagi method-method sebuah struct ke beberapa blok impl. Meskipun semuanya bisa dimasukkan ke dalam satu blok, memisahkannya dapat membuat kodemu lebih teratur dan mudah dibaca.

Berikut struct dengan fungsinya yang dibagi ke dalam dua blok implementasi:

struct BankAccount {
    balance: f64,
}

// Konstruktor dan query dasar
impl BankAccount {
    fn new(initial: f64) -> BankAccount {
        BankAccount { balance: initial }
    }
    
    fn balance(&self) -> f64 {
        self.balance
    }
}

// Method transaksi
impl BankAccount {
    fn deposit(&mut self, amount: f64) {
        self.balance += amount;
    }
    
    fn withdraw(&mut self, amount: f64) {
        self.balance -= amount;
    }
}

Kedua blok bekerja sama dengan lancar: Rust memperlakukannya seolah-olah keduanya adalah satu. Kamu bisa memanggil method apa pun, terlepas dari blok mana yang mendefinisikannya:

fn main() {
    let mut account = BankAccount::new(100.0);
    account.deposit(50.0);
    println!("{}", account.balance()); // 150
}

Pola ini menjadi sangat berguna saat struct-mu semakin besar. Kamu bisa mengelompokkan constructor, memisahkan method yang hanya membaca dari method yang mengubah data, atau mengaturnya berdasarkan fitur. Sebuah struct dapat memiliki impl sebanyak apa pun.

Tantangan

Mudah

Buat struct Player dengan dua field: name (String) dan score (u32).

Atur method struct tersebut dalam dua blok implementasi terpisah:

Blok impl pertama: Konstruktor dan kueri:

new: fungsi terkait yang menerima name: String dan mengembalikan Player dengan score bernilai 0
get_score: menerima &self dan mengembalikan skor saat ini sebagai u32

Blok impl kedua: Perubahan skor:

add_points: menerima &mut self dan points: u32, lalu menambahkan poin ke skor
reset_score: menerima &mut self dan mengatur ulang skor menjadi 0

Kamu akan menerima tiga input:

Baris pertama: nama pemain (String)
Baris kedua: poin yang ditambahkan pada ronde pertama (u32)
Baris ketiga: poin yang ditambahkan pada ronde kedua (u32)

Buat pemain menggunakan Player::new, tambahkan poin ronde pertama, cetak skornya, lalu atur ulang skor, tambahkan poin ronde kedua, dan cetak skor akhir.

Format output yang diharapkan:

{score_after_first_round}
{score_after_reset_and_second_round}

Coba sendiri

use std::io;

// TODO: Definisikan struct Player dengan field name (String) dan score (u32)


// TODO: Blok impl pertama: constructor dan method query (new, get_score)


// TODO: Blok impl kedua: method untuk mengubah skor (add_points, reset_score)


fn main() {
    let mut input = String::new();
    
    // Baca nama pemain
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let name = input.trim().to_string();
    
    // Baca poin ronde pertama
    input.clear();
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let first_round: u32 = input.trim().parse().expect("Invalid number");
    
    // Baca poin ronde kedua
    input.clear();
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let second_round: u32 = input.trim().parse().expect("Invalid number");
    
    // TODO: Buat pemain menggunakan Player::new
    // TODO: Tambahkan poin ronde pertama dan cetak skor
    // TODO: Atur ulang skor
    // TODO: Tambahkan poin ronde kedua dan cetak skor akhir
}