Início / coding / Perguntas / 78985975
Accepted
Olivier Lasne
Asked: 2024-09-15 03:22:59 +0800 CST

É possível definir que uma variável deve sempre saturar em operações aritméticas?

  • 772

Tenho uma variável na qual faço muitas operações aritméticas.

Meu código era mais ou menos assim:

let a: u32 = 3;
let res = (a*2) - 42

Tive um estouro quando aestava muito baixo, então tive que usar saturating_sub()para resolver o problema:

let a: u32 = 3;
let res = (a * 2).saturating_sub(42);

Isso funciona muito bem, mas saturating_subé um pouco menos legível que -.

Como tenho muitas dessas operações, e em todos os casos, quero asaturar. Eu estava pensando se é possível definir que asempre deve saturar . E não substituir every -por saturate_sub.

rust

1 respostas

  1. Best Answer

    Isto é std::num::Saturating, no entanto, ele só implementa operações com outros Saturating, não com o primitivo subjacente:

    let a = Saturating(3u32);
let res = (a * Saturating(2)) - Saturating(42);

    Se isso for um problema para você, você pode criar seu próprio tipo:

    use std::num::Saturating as StdSaturating;
use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};

#[derive(Clone, Copy, Debug)]
pub struct Saturating<T>(pub T);

macro_rules! impl_saturating_op {
    ( $trait:ident, $method:ident, $trait_assign:ident, $method_assign:ident => $($ty:ty),* ) => {
        $(
            impl $trait for Saturating<$ty> {
                type Output = Saturating<$ty>;
                fn $method(self, other: Saturating<$ty>) -> Self::Output {
                    Saturating(StdSaturating(self.0).$method(StdSaturating(other.0)).0)
                }
            }

            impl $trait<$ty> for Saturating<$ty> {
                type Output = Saturating<$ty>;
                fn $method(self, other: $ty) -> Self::Output {
                    Saturating(StdSaturating(self.0).$method(StdSaturating(other)).0)
                }
            }

            impl $trait<Saturating<$ty>> for $ty {
                type Output = Saturating<$ty>;
                fn $method(self, other: Saturating<$ty>) -> Self::Output {
                    Saturating(StdSaturating(self).$method(StdSaturating(other.0)).0)
                }
            }

            impl $trait_assign for Saturating<$ty> {
                fn $method_assign(&mut self, other: Saturating<$ty>) {
                    self.0 = StdSaturating(self.0).$method(StdSaturating(other.0)).0;
                }
            }

            impl $trait_assign<$ty> for Saturating<$ty> {
                fn $method_assign(&mut self, other: $ty) {
                    self.0 = StdSaturating(self.0).$method(StdSaturating(other)).0;
                }
            }
        )*
    }
}

impl_saturating_op!(Add, add, AddAssign, add_assign => i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize);
impl_saturating_op!(Sub, sub, SubAssign, sub_assign => i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize);
impl_saturating_op!(Mul, mul, MulAssign, mul_assign => i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize);
impl_saturating_op!(Div, div, DivAssign, div_assign => i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize);

fn main() {
    let a = Saturating(3u32);
    let res = (a * 2) - 42;
}
    • 5

relate perguntas