`const și static` în Rust

Bazele limbajului Rust Rust 1.0

const definește o valoare fixă calculată la compilare; static definește o variabilă globală cu o singură adresă, care trăiește tot programul.

Sintaxă

const NUME: Tip = expresie_constanta;
static NUME: Tip = expresie_constanta;
const fn nume(...) -> Tip { ... }      // funcție evaluabilă la compilare

Ce face `const și static`

const definește o constantă: o valoare cunoscută la compilare, cu tipul scris obligatoriu și numele cu majuscule (const TVA: f64 = 0.21;). Compilatorul copiază valoarea în fiecare loc unde este folosită, ca și cum ai fi scris-o acolo.

static definește un element global care există o singură dată în memorie, pe toată durata programului (are durata de viață 'static). Îl folosești când ai nevoie de o adresă fixă, de exemplu pentru un tabel mare sau pentru un contor atomic partajat de fire.

static mut există, dar orice acces la el cere unsafe, iar în ediția 2024 referințele la un static mut sunt eroare. Pentru stare globală modificabilă folosește tipuri sigure: AtomicU32, Mutex, OnceLock, LazyLock. const fn marchează funcțiile care pot fi apelate în inițializarea unei constante.

Exemple

Exemplul 1: Constante pentru valori fixe

LEI_PE_EURO și PRAG_TRANSPORT sunt calculate la compilare. Și LIMITA_BANI este o constantă, calculată de o const fn din altă constantă.

const LEI_PE_EURO: f64 = 4.97;
const PRAG_TRANSPORT: u32 = 150;
const LIMITA_BANI: u32 = in_bani(PRAG_TRANSPORT);

const fn in_bani(lei: u32) -> u32 {
    lei * 100
}

fn main() {
    let cos = 180;
    println!("Coș: {cos} lei = {:.2} euro", cos as f64 / LEI_PE_EURO);
    if cos >= PRAG_TRANSPORT {
        println!("Transport gratuit (prag: {PRAG_TRANSPORT} lei = {LIMITA_BANI} bani)");
    }
}

Rezultat

Coș: 180 lei = 36.22 euro
Transport gratuit (prag: 150 lei = 15000 bani)

Exemplul 2: static cu un contor atomic

VIZITE este o singură variabilă globală, modificată sigur din patru fire de execuție, fără unsafe, prin operații atomice. NUME_SITE este un text static.

use std::sync::atomic::{AtomicU32, Ordering};
use std::thread;

static NUME_SITE: &str = "dexblog.ro";
static VIZITE: AtomicU32 = AtomicU32::new(0);

fn main() {
    let fire: Vec<_> = (0..4)
        .map(|_| thread::spawn(|| {
            for _ in 0..250 {
                VIZITE.fetch_add(1, Ordering::Relaxed);
            }
        }))
        .collect();
    for f in fire {
        f.join().unwrap();
    }
    println!("{NUME_SITE}: {} vizite", VIZITE.load(Ordering::Relaxed));
}