tipuri scalare (întregi, f64, bool, char) în Rust

i8 i16 i32 i64 i128 isize      // întregi cu semn
u8 u16 u32 u64 u128 usize      // întregi fără semn
f32 f64                        // numere cu virgulă
bool                           // true sau false
char                           // un caracter Unicode, 4 octeți

Ce face tipuri scalare (întregi, f64, bool, char)

Întregii au mărimea în nume: i32 are 32 de biți cu semn, u8 are 8 biți fără semn (0–255). usize are mărimea unui pointer (64 de biți pe calculatoarele de azi) și este tipul indicilor și lungimilor. Un literal întreg fără alt indiciu este i32, iar unul cu virgulă este f64. Poți scrie 1_000_000 pentru lizibilitate și sufixe ca 255u8.

bool are două valori, true și false, și este singurul tip acceptat de if și while: Rust nu transformă automat 0 în fals. char reprezintă un caracter Unicode (inclusiv 'ș' sau un emoji) și ocupă 4 octeți, deci nu este același lucru cu un octet.

Depășirea unui întreg (de exemplu 255u8 + 1 calculat la rulare) oprește programul cu panică în modul debug; în modul release valoarea „se întoarce” (devine 0). Dacă vrei un comportament clar, folosește metodele checked_add, wrapping_add sau saturating_add.

Exemple

Exemplul 1: Limitele tipurilor și mărimea lor

Fiecare tip numeric are constantele MIN și MAX. size_of arată câți octeți ocupă un tip; char are 4, iar bool are 1.

use std::mem::size_of;

fn main() {
    println!("u8:  {} ... {}", u8::MIN, u8::MAX);
    println!("i32: {} ... {}", i32::MIN, i32::MAX);
    println!("u64 maxim: {}", u64::MAX);
    println!("f64 maxim: {:e}", f64::MAX);
    println!("bool: {} octet, char: {} octeți, usize: {} octeți",
             size_of::<bool>(), size_of::<char>(), size_of::<usize>());
}

Rezultat

u8:  0 ... 255
i32: -2147483648 ... 2147483647
u64 maxim: 18446744073709551615
f64 maxim: 1.7976931348623157e308
bool: 1 octet, char: 4 octeți, usize: 8 octeți

Exemplul 2: bool și char în practică

true și false rezultă din comparații. Un char are metode utile: is_alphabetic, to_uppercase. Diacriticele sunt caractere obișnuite pentru Rust.

fn main() {
    let media = 8.75;
    let promovat: bool = media >= 5.0;
    let are_bursa = media >= 9.5;
    println!("promovat: {promovat}, bursă: {are_bursa}, ambele: {}", promovat && are_bursa);

    let litera: char = 'ș';
    println!("{litera} este literă: {}", litera.is_alphabetic());
    println!("majusculă: {}", litera.to_uppercase());
    println!("cod Unicode: U+{:04X}", litera as u32);
}

Rezultat

promovat: true, bursă: false, ambele: false
ș este literă: true
majusculă: Ș
cod Unicode: U+0219

Exemplul 3: Depășirea unui întreg

Programul compilat în modul debug (cum face cargo run implicit) verifică fiecare adunare. 250 + 10 nu încape într-un u8, deci programul se oprește cu panică în loc să continue cu o valoare greșită.

fn adauga(stoc: u8, cantitate: u8) -> u8 {
    stoc + cantitate
}

fn main() {
    println!("{}", adauga(100, 20));
    println!("{}", adauga(250, 10));
}

Rezultat (programul se oprește cu panică)

120

thread 'main' (14470314) panicked at main.rs:2:5:
attempt to add with overflow
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Greșeli frecvente

• Scrii if numar { ... } ca în C. Rust cere un bool: scrie if numar != 0.
• Amesteci tipuri în calcule: let x: i32 = 5; let y: f64 = 2.5; x * y nu se compilează. Rust nu convertește automat între tipuri numerice; scrie x as f64 * y.
• Folosești u32 pentru o diferență care poate fi negativă (a - b cu b > a): în debug programul se oprește cu attempt to subtract with overflow. Alege i32/i64 sau checked_sub.
• Crezi că char este un octet. Un text String stochează caracterele în UTF-8, unde 'ș' ocupă 2 octeți; s.len() numără octeți, iar s.chars().count() numără caractere.

Comenzi înrudite

• as (conversii numerice): Convertește explicit o valoare numerică (sau char, bool) în alt tip primitiv. Conversia nu dă niciodată eroare, dar poate pierde informație.
• variabile și mutabilitate (let, mut): let creează o variabilă. Implicit nu poate fi modificată; cu let mut primește voie să-și schimbe valoarea.
• tuple (tupluri): Grupează un număr fix de valori, de tipuri diferite, într-o singură valoare. Elementele se citesc cu .0, .1 sau prin desfacere.
• array ([T; N]): Un șir de lungime fixă, cunoscută la compilare, cu elemente de același tip, păstrat direct pe stivă.