Operatori di Assegnazione in Rust

Gli operatori di assegnazione in Rust permettono di assegnare valori alle variabili e di combinare operazioni con l’assegnazione. Ricorda che le variabili devono essere dichiarate mut per essere riassegnate.

Assegnazione Base

fn main() {
    let x = 10;        // Immutabile
    let mut y = 20;    // Mutabile
    y = 30;            // OK: y è mutabile
    // x = 15;         // ERRORE: x non è mutabile
}

Operatori di Assegnazione Composti

Operatore	Equivalente	Trait
+=	x = x + y	AddAssign
-=	x = x - y	SubAssign
*=	x = x * y	MulAssign
/=	x = x / y	DivAssign
%=	x = x % y	RemAssign

fn main() {
    let mut x = 10;

    x += 5;   // x = 15
    x -= 3;   // x = 12
    x *= 2;   // x = 24
    x /= 4;   // x = 6
    x %= 4;   // x = 2

    println!("{}", x); // 2
}

Operatori Bitwise Composti

Operatore	Equivalente	Trait
&=	x = x & y	BitAndAssign
|=	x = x | y	BitOrAssign
^=	x = x ^ y	BitXorAssign
<<=	x = x << y	ShlAssign
>>=	x = x >> y	ShrAssign

fn main() {
    let mut x: u8 = 0b1100; // 12

    x &= 0b1010;  // 1000 → 8
    x |= 0b0011;  // 1011 → 11
    x ^= 0b0101;  // 1110 → 14
    x <<= 1;      // 11100 → 28
    x >>= 2;      // 111 → 7
}

Assegnazione Destrutturante

Rust supporta l’assegnazione con pattern destructuring:

fn main() {
    let (mut a, mut b) = (1, 2);
    (a, b) = (b, a); // Swap
    println!("{} {}", a, b); // 2 1

    let mut punto = (0.0, 0.0);
    (punto.0, punto.1) = (3.0, 4.0);
}

Implementare Operatori Composti per Tipi Personalizzati

use std::ops::AddAssign;

#[derive(Debug)]
struct Vettore {
    x: f64,
    y: f64,
}

impl AddAssign for Vettore {
    fn add_assign(&mut self, other: Self) {
        self.x += other.x;
        self.y += other.y;
    }
}

fn main() {
    let mut v = Vettore { x: 1.0, y: 2.0 };
    v += Vettore { x: 3.0, y: 4.0 };
    println!("{:?}", v); // Vettore { x: 4.0, y: 6.0 }
}

Conclusione

Gli operatori di assegnazione composti in Rust sono implementati tramite trait della libreria standard, rendendoli estensibili ai tipi personalizzati. Ricorda che la variabile deve essere mut per poter essere riassegnata e che Rust non supporta l’operatore := né l’assegnazione multipla con virgole come in altri linguaggi.