`i32::wrapping_add` în Rust

Numere întregi: i32 Rust 1.0 (overflowing_add: 1.7)

Adună cu „întoarcere”: după MAX urmează MIN. overflowing_add spune și dacă a avut loc depășirea.

Sintaxă

const fn wrapping_add(self, rhs: i32) -> i32
const fn overflowing_add(self, rhs: i32) -> (i32, bool)

Ce face `i32::wrapping_add`

wrapping_add face aritmetica modulo 2³²: rezultatul care nu încape „se întoarce” la celălalt capăt, ca la un kilometraj. i32::MAX.wrapping_add(1) == i32::MIN. Este comportamentul din modul release, dar scris explicit, deci identic și în debug.

overflowing_add returnează perechea (rezultat_intors, a_depasit). Le folosești pentru funcții de hash, sume de control, generatoare de numere pseudo-aleatoare și contoare circulare. Există și variantele wrapping_sub, wrapping_mul, overflowing_sub etc.

Parametri

Parametru	Descriere
`rhs`	Al doilea termen.

Ce returnează

wrapping_add: i32. overflowing_add: (i32, bool).

Exemple

Exemplul 1: Întoarcerea la capăt

fn main() {
    println!("MAX + 1 = {}", i32::MAX.wrapping_add(1));
    println!("MIN - 1 = {}", i32::MIN.wrapping_sub(1));
    println!("overflowing 10 + 5:  {:?}", 10_i32.overflowing_add(5));
    println!("overflowing MAX + 1: {:?}", i32::MAX.overflowing_add(1));

    let octet: u8 = 250;
    println!("250u8 + 10 = {}", octet.wrapping_add(10));
}

Rezultat

MAX + 1 = -2147483648
MIN - 1 = 2147483647
overflowing 10 + 5:  (15, false)
overflowing MAX + 1: (-2147483648, true)
250u8 + 10 = 4

Exemplul 2: Un hash simplu pentru texte

Înmulțirile depășesc repede limita; la funcțiile de hash, întoarcerea este exact ce vrem.

fn hash(text: &str) -> u32 {
    let mut h: u32 = 2166136261;
    for b in text.bytes() {
        h ^= b as u32;
        h = h.wrapping_mul(16777619);
    }
    h
}

fn main() {
    for cuvant in ["Iași", "Cluj", "iasi"] {
        println!("{cuvant:5} -> {:010}", hash(cuvant));
    }
}