BAB 7: Konstanta
Konstanta di Rust: const dan static, perbedaan keduanya, evaluasi saat kompilasi, penamaan huruf besar, serta batasan const fn yang ditolak kompilator.
Nilai yang tidak berubah sepanjang program sebaiknya diberi nama. Di Rust ada 2 cara: const dan static. Keduanya tidak bisa diubah saat program berjalan, keduanya ditulis dengan huruf besar, tetapi cara penyimpanannya berbeda dan perbedaan itu terlihat saat program dijalankan.
Bab ini membahas const, static, const fn, dan batasan yang membuat sebagian ekspresi ditolak kompilator. Semua contoh dikompilasi dengan rustc 1.100.0, dan pesan kesalahan yang dikutip adalah keluaran asli kompilator.
const dan aturan penulisannya
const dideklarasikan di luar atau di dalam fungsi, wajib memakai anotasi tipe, dan nilainya harus bisa dihitung saat kompilasi:
const BATAS: u32 = 10;
fn main() {
println!("BATAS = {BATAS}");
}
BATAS = 10
Anotasi tipe wajib. Tanpa itu, kompilasi berhenti:
const X = 5;
fn main() {
println!("{X}");
}
error: missing type for `const` item
--> konst_tipe.rs:1:8
|
1 | const X = 5;
| ^ help: provide a type for the constant: `: i32`
Kewajiban ini masuk akal karena const tidak punya nilai awal yang bisa dipakai menyimpulkan tipe, dan kompilator perlu tahu tipe sebelum menghitung nilainya.
Nama konstanta ditulis dengan huruf besar dan garis bawah. Kalau ditulis huruf kecil, kompilasi tetap berhasil tetapi memberi peringatan:
warning: constant `batas` should have an upper case name
|
1 | const batas: u32 = 10;
| ^^^^^
= note: `#[warn(non_upper_case_globals)]` (part of `#[warn(nonstandard_style)]`) on by default
const fn untuk perhitungan saat kompilasi
Fungsi yang ditandai const bisa dipakai untuk menghitung nilai konstanta. Hasilnya dihitung saat kompilasi, bukan saat program berjalan:
const BATAS: u32 = 10;
const fn lipat_dua(n: u32) -> u32 {
n * 2
}
const HASIL: u32 = lipat_dua(BATAS);
fn main() {
println!("HASIL = {HASIL}");
}
HASIL = 20
const fn hanya boleh memuat operasi yang bisa dijalankan kompilator. Memanggil fungsi biasa di dalamnya ditolak, dan begitulah batas antara kode yang bisa dihitung di awal dari kode yang baru bisa dijalankan saat program hidup.
const di dalam fungsi
const juga boleh dideklarasikan di dalam fungsi. Cakupannya hanya fungsi itu, dan nilainya tetap dihitung saat kompilasi:
fn main() {
const LOKAL: i32 = 5;
println!("LOKAL = {LOKAL}");
}
LOKAL = 5
Bentuk ini berguna untuk nilai yang hanya dipakai 1 fungsi, sehingga tidak perlu mengotori cakupan berkas.
static
static juga tidak berubah, tetapi nilainya disimpan di 1 tempat di memori dan dipakai bersama oleh seluruh program. Alamatnya tetap sepanjang program berjalan.
static NAMA: &str = "Rust";
fn main() {
println!("NAMA = {NAMA}");
}
NAMA = Rust
Perbedaan const dan static yang bisa diukur: alamat const yang dipakai 2 kali bisa sama, karena kompilator menyatukan nilainya, sedangkan static pasti punya 1 alamat. Saya menguji keduanya dengan membandingkan pointer hasil &BATAS as *const u32 pada 2 pemakaian, dan hasilnya true untuk kedua bentuk.
Perbedaan yang tidak terlihat dari pointer baru terasa pada kasus yang menuntut alamat tunggal sepanjang program, misalnya data yang dibaca kode C lewat FFI, atau penghitung global. Pada kasus seperti itu static diperlukan, karena const boleh disalin ke beberapa tempat oleh kompilator dan alamatnya tidak dijamin tunggal di semua kondisi.
| Hal | const | static |
|---|---|---|
| Wajib anotasi tipe | ya | ya |
| Bisa dihitung saat kompilasi | ya | ya |
| Alamat di memori | bisa disatukan kompilator | 1 alamat tetap |
| Bisa mutable | tidak | tidak, kecuali static mut |
| Ditulis dengan huruf besar | ya | ya |
static mut dan unsafe
static mut memungkinkan nilai diubah, tetapi seluruh aksesnya harus di dalam blok unsafe, karena kompilator tidak bisa menjamin tidak ada 2 bagian program yang mengubahnya bersamaan:
static mut HITUNG: u32 = 0;
fn main() {
unsafe {
HITUNG += 1;
println!("HITUNG = {HITUNG}");
}
}
HITUNG = 1
Bentuk ini ada untuk kasus khusus seperti interaksi dengan kode C. Untuk kebutuhan sehari-hari, static mut sebaiknya dihindari dan diganti tipe yang aman dipakai bersama, misalnya AtomicU32 atau Mutex.
Nilai yang tidak boleh menjadi konstanta
Nilai const harus bisa dihitung tanpa menjalankan program. Pemanggilan fungsi yang mengalokasikan memori, seperti String::from, ditolak:
const NAMA: String = String::from("Rust");
fn main() {
println!("{NAMA}");
}
error[E0015]: cannot call non-const associated function `<String as From<&str>>::from` in constants
--> const_salah.rs:1:22
|
1 | const NAMA: String = String::from("Rust");
| ^^^^^^^^^^^^^^^^^^^^
= note: calls in constants are limited to constant functions, tuple structs and tuple variants
Pesan itu menyebut batasnya dengan jelas: konstanta hanya boleh memanggil fungsi const, struct tuple, dan varian tuple. Untuk teks yang perlu dialokasikan, static NAMA: &str = "Rust"; tetap sah karena tidak mengalokasikan memori saat program berjalan.
Konstanta bertipe koleksi dan lintas modul
const tidak terbatas pada angka. Array, tuple, dan teks juga bisa menjadi konstanta, dan konstanta di dalam modul bisa dipakai dari luar selama ditandai pub:
const ANGKA: [u8; 3] = [1, 2, 3];
const PASANGAN: (u8, u8) = (4, 5);
mod batas {
pub const MAKS: u32 = 100;
}
fn main() {
println!("{:?} {:?}", ANGKA, PASANGAN);
println!("MAKS = {}", batas::MAKS);
println!("jumlah = {}", ANGKA[0] as u32 + batas::MAKS);
}
[1, 2, 3] (4, 5)
MAKS = 100
jumlah = 101
Perhatikan as u32 pada baris terakhir. Tanpa itu, kompilasi gagal karena ANGKA[0] bertipe u8 sedangkan batas::MAKS bertipe u32:
error[E0308]: mismatched types
|
11 | println!("jumlah = {}", ANGKA[0] + batas::MAKS);
| ^^^^^^^^^^^ expected `u8`, found `u32`
Konstanta tetap membawa tipenya masing-masing, dan pencampuran tipe tetap harus diselesaikan secara eksplisit seperti nilai biasa.
Kapan memakai const, static, atau let
| Kebutuhan | Pilihan |
|---|---|
| batas angka yang dipakai banyak fungsi | const |
| nilai yang dihitung dari konstanta lain | const dengan const fn |
| data yang harus punya 1 alamat tetap | static |
| nilai yang hanya dipakai 1 fungsi | const di dalam fungsi |
| nilai yang berubah saat program berjalan | let dengan mut |
Patokan yang saya pakai: const sebagai pilihan pertama untuk nilai tetap, static hanya ketika alamatnya memang harus tunggal, dan static mut tidak dipakai kecuali berhadapan dengan kode luar.
Ringkasan
const dan static sama-sama tidak bisa diubah dan wajib memakai anotasi tipe. const dihitung saat kompilasi dan nilainya bisa disatukan kompilator, sedangkan static menempati 1 alamat tetap selama program berjalan. Keduanya ditulis dengan huruf besar, dan nama huruf kecil memunculkan peringatan non_upper_case_globals.
const fn memungkinkan perhitungan saat kompilasi, tetapi hanya untuk operasi yang bisa dijalankan kompilator. static mut memungkinkan perubahan dengan syarat seluruh aksesnya di dalam unsafe, dan pemanggilan fungsi yang mengalokasikan memori seperti String::from ditolak dengan kesalahan E0015.
Latihan
- Buat
const BATAS: u32 = 10;dan fungsiconst fn lipat_dua, lalu cetak hasilnya. - Tulis nama konstanta dengan huruf kecil, kompilasi, dan baca peringatan yang muncul.
- Coba jadikan
String::from("Rust")sebagai nilaiconst, lalu catat nomor kesalahannya. - Bandingkan alamat
constdanstaticmemakai pointer, lalu jelaskan hasilnya.
Referensi
- The Rust Programming Language. Variables and Mutability, bagian constants.
- The Rust Reference. Constant items.
- The Rust Reference. Static items.