如何在 Rust 中返回 integer 溢出标志？

Question

Swift has integer overflow arithmetic functions which return a flag whether the number has overflowed or not. Do we have same thing in Rust?

Answer 1

Since Rust 1.7.0, there's overflowing_<operation>(rhs) defined on integer types.

Example for overflowing_add :

Calculates self + rhs

Returns a tuple of the addition along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would have occurred then the wrapped value is returned.

Example:

use std::i64;

assert_eq!(5i64.overflowing_add(2), (7, false));
assert_eq!(i64::MAX.overflowing_add(1), (i64::MIN, true));

( playground )

Answer 2

As you note, there are intrinsics for this but these are unsafe and somewhat annoying to use.

Before Rust 1.0, the standard library provided wrappers that detect the overflow for the 4 arithmetic operations in the form of CheckedAdd , CheckedSub , CheckedMul and CheckedDiv .

As of Rust 1.0, these traits no longer exist and there are just inherent methods on each numeric type, such as i32::checked_add .

However, these just detect overflow and do not return the overflowed-result:

fn main() {
    println!("{:?}", 5u16.checked_add(65530u16));
    println!("{:?}", 6u16.checked_add(65530u16));
}

( playground )

Prints:

Some(65535)
None

Answer 3

Rust has integer arithmetic intrinsics such as add_with_overflow .

pub unsafe extern "rust-intrinsic" fn add_with_overflow<T>(
    x: T, 
    y: T
) -> (T, bool)

Answer 4

• Wrapping operations return the value equivalent to the mathematically correct result modulo the range of the value:

   fn main() { { let s=500_u16.wrapping_mul(500); println!("{}", s); } }

in this case

   s=53392 // (500*500) module 2^16 =53392

• Overflowing operations return a tuple (result, overflowed) , result is the wrapping version of the function would return as above, and overflowed is a bool indicating whether an overflow occurred. You can use this bool as the flag:

   fn main() { { // because u8 0 to 2^8 –1 (0 to 255) let s=255_u8.overflowing_add(2); // {:?} is used to print a value that implements Debug trait println!("{:?}", s); // s= (1, true) } }

You can test the code here: https://play.rust-lang.org/