Contoh Program yang Menggunakan Struct
Untuk memahami kapan kita ingin menggunakan struct, mari kita tulis program yang menghitung luas sebuah persegi panjang. Kita akan mulai dengan variabel tunggal, lalu me-refactor program itu sampai kita menggantinya dengan struct.
Mari kita buat project binary baru dengan Cargo bernama rectangles yang menerima lebar dan tinggi sebuah persegi panjang dalam satuan piksel lalu menghitung luas persegi panjang itu. Listing 5-8 menunjukkan program singkat yang melakukan tepat hal tersebut di src/main.rs project kita.
fn main() {
let width1 = 30;
let height1 = 50;
println!(
"The area of the rectangle is {} square pixels.",
area(width1, height1)
);
}
fn area(width: u32, height: u32) -> u32 {
width * height
}
Sekarang, jalankan program ini dengan cargo run:
$ cargo run
Compiling rectangles v0.1.0 (file:///projects/rectangles)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.42s
Running `target/debug/rectangles`
The area of the rectangle is 1500 square pixels.
Kode ini berhasil menemukan luas persegi panjang dengan memanggil fungsi area untuk tiap dimensi, tapi masih ada yang bisa kita perbaiki agar kode ini lebih jelas dan mudah dibaca.
Masalah kode ini terlihat jelas dari signature area:
fn main() {
let width1 = 30;
let height1 = 50;
println!(
"The area of the rectangle is {} square pixels.",
area(width1, height1)
);
}
fn area(width: u32, height: u32) -> u32 {
width * height
}
Fungsi area seharusnya menghitung luas satu persegi panjang, tapi fungsi yang kita tulis punya dua parameter, dan tidak ada satu pun bagian program kita yang menjelaskan bahwa kedua parameter itu saling berkaitan. Lebar dan tinggi akan lebih mudah dibaca dan diatur kalau kita kelompokkan bersama. Kita sudah membahas salah satu caranya di bagian “Tipe Tuple” Bab 3, yaitu dengan menggunakan tuple.
Refactoring dengan Tuple
Listing 5-9 menunjukkan versi lain dari program kita yang menggunakan tuple.
fn main() {
let rect1 = (30, 50);
println!(
"The area of the rectangle is {} square pixels.",
area(rect1)
);
}
fn area(dimensions: (u32, u32)) -> u32 {
dimensions.0 * dimensions.1
}
Dalam satu hal, program ini lebih baik. Tuple memberi sedikit struktur, dan kini kita hanya mengoper satu argumen. Tapi di sisi lain, versi ini kurang jelas: tuple tidak memberi nama pada elemennya, jadi kita harus mengakses bagian tuple lewat indeks, sehingga perhitungan kita jadi kurang terlihat jelas.
Tertukarnya lebar dan tinggi tidak masalah untuk perhitungan luas, tapi kalau kita ingin menggambar persegi panjang di layar, itu jadi masalah! Kita harus selalu mengingat bahwa width ada di indeks tuple 0 dan height ada di indeks tuple 1. Bagi orang lain, hal itu justru lebih sulit ditebak dan diingat kalau mereka memakai kode kita. Karena kita belum menyampaikan makna data kita di dalam kode, error jadi lebih mudah muncul.
Refactoring dengan Struct
Kita menggunakan struct untuk menambah makna dengan memberi label pada data. Tuple yang kita pakai bisa kita ubah menjadi struct yang punya nama untuk keseluruhannya sekaligus nama untuk tiap bagiannya, seperti ditunjukkan Listing 5-10.
struct Rectangle {
width: u32,
height: u32,
}
fn main() {
let rect1 = Rectangle {
width: 30,
height: 50,
};
println!(
"The area of the rectangle is {} square pixels.",
area(&rect1)
);
}
fn area(rectangle: &Rectangle) -> u32 {
rectangle.width * rectangle.height
}
RectangleDi sini kita sudah mendefinisikan sebuah struct dan menamainya Rectangle. Di dalam kurung kurawal, kita mendefinisikan field width dan height, yang keduanya bertipe u32. Lalu, di main, kita membuat sebuah instance Rectangle dengan lebar 30 dan tinggi 50.
Fungsi area kita kini didefinisikan dengan satu parameter yang kita beri nama rectangle, bertipe borrow immutable atas sebuah instance struct Rectangle. Seperti disebutkan di Bab 4, kita ingin meminjam struct itu alih-alih mengambil ownership-nya. Dengan begitu, main tetap memegang ownership dan bisa terus menggunakan rect1—itulah alasan kita memakai & pada signature fungsi dan pada saat kita memanggil fungsi itu.
Fungsi area mengakses field width dan height dari instance Rectangle (perhatikan bahwa mengakses field sebuah instance struct yang dipinjam tidak memindahkan nilai field itu, itulah sebabnya kamu sering melihat struct dipinjam). Signature fungsi area kita kini mengatakan persis apa yang kita maksud: hitung luas Rectangle menggunakan field width dan height-nya. Dengan begitu terlihat bahwa lebar dan tinggi saling berkaitan, dan kita memberi nama yang deskriptif pada nilai-nilai itu alih-alih memakai indeks tuple 0 dan 1. Ini sebuah kemenangan untuk kejelasan.
Menambah Kemampuan dengan Trait yang Di-derive
Akan sangat berguna kalau kita bisa mencetak sebuah instance Rectangle beserta nilai semua field-nya saat sedang debug program. Listing 5-11 mencoba memakai macro println! seperti yang kita gunakan di bab-bab sebelumnya. Tapi cara ini tidak akan berhasil.
struct Rectangle {
width: u32,
height: u32,
}
fn main() {
let rect1 = Rectangle {
width: 30,
height: 50,
};
println!("rect1 is {rect1}");
}
RectangleKetika kita mengompilasi kode ini, kita mendapat error dengan pesan inti berikut:
error[E0277]: `Rectangle` doesn't implement `std::fmt::Display`
Macro println! bisa melakukan banyak jenis penataan, dan secara bawaan, kurung kurawal memberi tahu println! untuk memakai penataan yang dikenal sebagai Display: keluaran yang ditujukan langsung bagi pengguna akhir. Tipe-tipe primitif yang sudah kita lihat sejauh ini mengimplementasikan Display secara bawaan karena hanya ada satu cara kamu ingin menampilkan 1 atau tipe primitif lain kepada pengguna. Tapi dengan struct, cara println! menata keluarannya jadi tidak jelas karena ada lebih banyak kemungkinan tampilan: Mau pakai koma atau tidak? Mau mencetak kurung kurawalnya? Apakah semua field harus ditampilkan? Karena ambiguitas ini, Rust tidak menebak apa yang kita inginkan, dan struct tidak punya implementasi Display yang disediakan untuk dipakai bersama println! dan placeholder {}.
Kalau kita lanjut membaca error-nya, kita akan menemukan catatan yang membantu ini:
help: the trait `std::fmt::Display` is not implemented for `Rectangle`
--> src/main.rs:1:1
Mari kita coba! Pemanggilan macro println! kini akan menjadi println!("rect1 is {rect1:?}");. Menaruh spesifier :? di dalam kurung kurawal memberi tahu println! bahwa kita ingin memakai format keluaran bernama Debug. Trait Debug membuat kita bisa mencetak struct dengan cara yang berguna bagi developer sehingga kita bisa melihat nilainya saat debug kode.
Kompilasi kode dengan perubahan ini. Yah! Kita masih mendapat error:
error[E0277]: `Rectangle` doesn't implement `Debug`
Tapi sekali lagi, compiler memberi kita catatan yang membantu:
| required by this formatting parameter
|
Rust memang menyediakan kemampuan untuk mencetak informasi debug, tapi kita harus secara eksplisit memilih mengaktifkan kemampuan itu agar tersedia untuk struct kita. Caranya, kita menambahkan atribut luar #[derive(Debug)] tepat sebelum definisi struct, seperti ditunjukkan Listing 5-12.
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
fn main() {
let rect1 = Rectangle {
width: 30,
height: 50,
};
println!("rect1 is {rect1:?}");
}
Debug dan mencetak instance Rectangle dengan penataan debugSekarang ketika kita menjalankan program, tidak ada error yang muncul, dan kita akan melihat keluaran berikut:
$ cargo run
Compiling rectangles v0.1.0 (file:///projects/rectangles)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.48s
Running `target/debug/rectangles`
rect1 is Rectangle { width: 30, height: 50 }
Keren! Bukan keluaran yang paling cantik, tapi keluaran ini menampilkan nilai semua field dari instance tersebut, yang jelas sangat membantu saat debug. Kalau kita punya struct yang lebih besar, akan berguna kalau keluarannya sedikit lebih mudah dibaca; untuk itu, kita bisa memakai {:#?} alih-alih {:?} di dalam string println!. Pada contoh ini, gaya {:#?} akan menghasilkan keluaran berikut:
$ cargo run
Compiling rectangles v0.1.0 (file:///projects/rectangles)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.48s
Running `target/debug/rectangles`
rect1 is Rectangle {
width: 30,
height: 50,
}
Cara lain untuk mencetak nilai dengan format Debug adalah memakai macro dbg!, yang mengambil ownership atas sebuah ekspresi (berbeda dengan println! yang mengambil reference), mencetak file dan nomor baris tempat pemanggilan macro dbg! itu berada di kode kamu beserta nilai hasil ekspresi tersebut, lalu mengembalikan ownership atas nilai itu.
Catatan: Memanggil macro
dbg!mencetak ke stream console standard error (stderr), berbeda denganprintln!yang mencetak ke stream console standard output (stdout). Kita akan membahasstderrdanstdoutlebih lanjut di bagian “Mengalihkan Error ke Standard Error” di Bab 12.
Berikut contoh di mana kita ingin melihat nilai yang ditetapkan ke field width, sekaligus nilai keseluruhan struct di rect1:
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
fn main() {
let scale = 2;
let rect1 = Rectangle {
width: dbg!(30 * scale),
height: 50,
};
dbg!(&rect1);
}
Kita bisa membungkus ekspresi 30 * scale dengan dbg! dan, karena dbg! mengembalikan ownership atas nilai ekspresi itu, field width akan mendapat nilai yang sama seolah-olah tidak ada pemanggilan dbg! di sana. Kita tidak ingin dbg! mengambil ownership atas rect1, jadi pada pemanggilan berikutnya kita memakai reference ke rect1. Berikut keluaran dari contoh ini:
$ cargo run
Compiling rectangles v0.1.0 (file:///projects/rectangles)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.61s
Running `target/debug/rectangles`
[src/main.rs:10:16] 30 * scale = 60
[src/main.rs:14:5] &rect1 = Rectangle {
width: 60,
height: 50,
}
Kita bisa melihat keluaran pertama berasal dari src/main.rs baris 10, tempat kita men-debug ekspresi 30 * scale, dan nilai hasilnya adalah 60 (penataan Debug yang diimplementasikan untuk integer hanya mencetak nilainya saja). Pemanggilan dbg! di baris 14 src/main.rs mengeluarkan nilai &rect1, yaitu struct Rectangle. Keluaran ini memakai penataan Debug yang rapi dari tipe Rectangle. Macro dbg! bisa sangat membantu ketika kamu berusaha memahami apa yang dilakukan kode kamu!
Selain trait Debug, Rust menyediakan sejumlah trait yang bisa kita gunakan bersama atribut derive untuk menambahkan perilaku berguna pada tipe kustom kita. Trait-trait beserta perilakunya terdaftar di Lampiran C. Kita akan membahas cara mengimplementasikan trait-trait itu dengan perilaku kustom, sekaligus cara membuat trait milikmu sendiri, di Bab 10. Selain derive, masih banyak atribut lain; untuk informasi lebih lanjut, lihat bagian “Atribut” pada Rust Reference.
Fungsi area kita sangat spesifik: ia hanya menghitung luas persegi panjang. Akan lebih baik kalau kita kaitkan perilaku ini lebih erat dengan struct Rectangle kita karena fungsi itu tidak akan bekerja dengan tipe lain. Mari kita lihat bagaimana kita bisa melanjutkan refactor kode ini dengan mengubah fungsi area menjadi method area yang didefinisikan pada tipe Rectangle kita.