Foundation

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:

RSRUST
const BATAS: u32 = 10;

fn main() {
    println!("BATAS = {BATAS}");
}
CodeTEXT
BATAS = 10

Anotasi tipe wajib. Tanpa itu, kompilasi berhenti:

RSRUST
const X = 5;

fn main() {
    println!("{X}");
}
CodeTEXT
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:

CodeTEXT
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:

RSRUST
const BATAS: u32 = 10;

const fn lipat_dua(n: u32) -> u32 {
    n * 2
}

const HASIL: u32 = lipat_dua(BATAS);

fn main() {
    println!("HASIL = {HASIL}");
}
CodeTEXT
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:

RSRUST
fn main() {
    const LOKAL: i32 = 5;
    println!("LOKAL = {LOKAL}");
}
CodeTEXT
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.

RSRUST
static NAMA: &str = "Rust";

fn main() {
    println!("NAMA = {NAMA}");
}
CodeTEXT
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.

Halconststatic
Wajib anotasi tipeyaya
Bisa dihitung saat kompilasiyaya
Alamat di memoribisa disatukan kompilator1 alamat tetap
Bisa mutabletidaktidak, kecuali static mut
Ditulis dengan huruf besaryaya

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:

RSRUST
static mut HITUNG: u32 = 0;

fn main() {
    unsafe {
        HITUNG += 1;
        println!("HITUNG = {HITUNG}");
    }
}
CodeTEXT
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:

RSRUST
const NAMA: String = String::from("Rust");

fn main() {
    println!("{NAMA}");
}
CodeTEXT
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:

RSRUST
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);
}
CodeTEXT
[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:

CodeTEXT
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

KebutuhanPilihan
batas angka yang dipakai banyak fungsiconst
nilai yang dihitung dari konstanta lainconst dengan const fn
data yang harus punya 1 alamat tetapstatic
nilai yang hanya dipakai 1 fungsiconst di dalam fungsi
nilai yang berubah saat program berjalanlet 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

  1. Buat const BATAS: u32 = 10; dan fungsi const fn lipat_dua, lalu cetak hasilnya.
  2. Tulis nama konstanta dengan huruf kecil, kompilasi, dan baca peringatan yang muncul.
  3. Coba jadikan String::from("Rust") sebagai nilai const, lalu catat nomor kesalahannya.
  4. Bandingkan alamat const dan static memakai pointer, lalu jelaskan hasilnya.

Referensi

  1. The Rust Programming Language. Variables and Mutability, bagian constants.
  2. The Rust Reference. Constant items.
  3. The Rust Reference. Static items.