算术运算符 #

一、运算符概述 #

Rust支持常见的算术运算符，用于数值计算。

二、基本算术运算符 #

2.1 运算符列表 #

运算符	说明	示例
`+`	加法	`a + b`
`-`	减法	`a - b`
`*`	乘法	`a * b`
`/`	除法	`a / b`
`%`	取余	`a % b`

2.2 整数运算 #

rust

fn main() {
    let a = 10;
    let b = 3;
    
    println!("加法: {} + {} = {}", a, b, a + b);
    println!("减法: {} - {} = {}", a, b, a - b);
    println!("乘法: {} * {} = {}", a, b, a * b);
    println!("除法: {} / {} = {}", a, b, a / b);
    println!("取余: {} % {} = {}", a, b, a % b);
}

2.3 浮点运算 #

rust

fn main() {
    let a = 10.0;
    let b = 3.0;
    
    println!("加法: {} + {} = {}", a, b, a + b);
    println!("减法: {} - {} = {}", a, b, a - b);
    println!("乘法: {} * {} = {}", a, b, a * b);
    println!("除法: {} / {} = {}", a, b, a / b);
    println!("取余: {} % {} = {}", a, b, a % b);
}

三、整数除法 #

3.1 向零取整 #

整数除法向零取整：

rust

fn main() {
    println!("7 / 3 = {}", 7 / 3);    // 2
    println!("7 / -3 = {}", 7 / -3);  // -2
    println!("-7 / 3 = {}", -7 / 3);  // -2
    println!("-7 / -3 = {}", -7 / -3);// 2
}

3.2 除零处理 #

整数除以零会导致panic：

rust

fn main() {
    // let x = 10 / 0;  // panic: attempt to divide by zero
    
    // 使用 checked_div 安全除法
    match 10.checked_div(0) {
        Some(result) => println!("结果: {}", result),
        None => println!("除零错误"),
    }
}

四、溢出处理 #

4.1 Debug模式 #

Debug模式下整数溢出会panic：

rust

fn main() {
    let mut x: u8 = 255;
    // x += 1;  // debug模式下panic
}

4.2 Release模式 #

Release模式下溢出会回绕：

rust

fn main() {
    let x: u8 = 255;
    let y = x.wrapping_add(1);
    println!("255 + 1 = {}", y);  // 0
}

4.3 安全运算方法 #

rust

fn main() {
    let a: u8 = 255;
    
    // wrapping_*: 回绕运算
    println!("wrapping_add: {}", a.wrapping_add(1));  // 0
    
    // checked_*: 检查溢出
    match a.checked_add(1) {
        Some(v) => println!("结果: {}", v),
        None => println!("溢出"),
    }
    
    // saturating_*: 饱和运算
    println!("saturating_add: {}", a.saturating_add(1));  // 255
    
    // overflowing_*: 返回结果和溢出标志
    let (result, overflowed) = a.overflowing_add(1);
    println!("结果: {}, 溢出: {}", result, overflowed);
}

五、复合赋值运算符 #

5.1 运算符列表 #

运算符	说明	等价形式
`+=`	加法赋值	`a = a + b`
`-=`	减法赋值	`a = a - b`
`*=`	乘法赋值	`a = a * b`
`/=`	除法赋值	`a = a / b`
`%=`	取余赋值	`a = a % b`

5.2 使用示例 #

rust

fn main() {
    let mut a = 10;
    
    a += 5;
    println!("+= 5: {}", a);  // 15
    
    a -= 3;
    println!("-= 3: {}", a);  // 12
    
    a *= 2;
    println!("*= 2: {}", a);  // 24
    
    a /= 4;
    println!("/= 4: {}", a);  // 6
    
    a %= 4;
    println!("%= 4: {}", a);  // 2
}

六、一元运算符 #

6.1 负号 #

rust

fn main() {
    let x = 5;
    let y = -x;
    
    println!("x = {}, -x = {}", x, y);
}

6.2 注意事项 #

负号运算需要类型支持：

rust

fn main() {
    let x: i32 = 5;
    let y = -x;  // 正确：i32 支持负号
    
    // let z: u32 = 5;
    // let w = -z;  // 错误：u32 不支持负号
}

七、运算符优先级 #

7.1 优先级规则 #

从高到低：

* / %
+ -

rust

fn main() {
    let result = 2 + 3 * 4;
    println!("2 + 3 * 4 = {}", result);  // 14
    
    let result = (2 + 3) * 4;
    println!("(2 + 3) * 4 = {}", result);  // 20
}

7.2 使用括号 #

建议使用括号明确优先级：

rust

fn main() {
    let a = 1 + 2 * 3 - 4 / 2;
    println!("1 + 2 * 3 - 4 / 2 = {}", a);  // 5
    
    let b = ((1 + 2) * 3 - 4) / 2;
    println!("((1 + 2) * 3 - 4) / 2 = {}", b);  // 2
}

八、类型一致性 #

8.1 相同类型运算 #

运算符要求操作数类型相同：

rust

fn main() {
    let a: i32 = 10;
    let b: i32 = 3;
    let c = a + b;  // 正确
    
    // let d: i64 = 5;
    // let e = a + d;  // 错误：类型不匹配
}

8.2 类型转换 #

需要显式转换：

rust

fn main() {
    let a: i32 = 10;
    let b: i64 = 5;
    
    let c = a as i64 + b;  // 转换后运算
    println!("c = {}", c);
}

九、实践示例 #

9.1 计算器 #

rust

fn calculate(a: i32, b: i32, op: char) -> Option<i32> {
    match op {
        '+' => Some(a + b),
        '-' => Some(a - b),
        '*' => Some(a * b),
        '/' => {
            if b != 0 {
                Some(a / b)
            } else {
                None
            }
        }
        '%' => {
            if b != 0 {
                Some(a % b)
            } else {
                None
            }
        }
        _ => None,
    }
}

fn main() {
    let operations = vec![('+', 10, 5), ('-', 10, 5), ('*', 10, 5), ('/', 10, 5), ('/', 10, 0)];
    
    for (op, a, b) in operations {
        match calculate(a, b, op) {
            Some(result) => println!("{} {} {} = {}", a, op, b, result),
            None => println!("{} {} {} = 错误", a, op, b),
        }
    }
}

9.2 温度转换 #

rust

fn celsius_to_fahrenheit(c: f64) -> f64 {
    c * 9.0 / 5.0 + 32.0
}

fn fahrenheit_to_celsius(f: f64) -> f64 {
    (f - 32.0) * 5.0 / 9.0
}

fn main() {
    let c = 25.0;
    let f = celsius_to_fahrenheit(c);
    println!("{}°C = {}°F", c, f);
    
    let f = 77.0;
    let c = fahrenheit_to_celsius(f);
    println!("{}°F = {}°C", f, c);
}

十、总结 #

本章学习了：

基本算术运算符
整数除法特点
溢出处理方法
复合赋值运算符
一元运算符
运算符优先级
类型一致性要求

下一章，我们将学习比较运算符。