Rust: Rust 运算符与表达式：从算术到位运算全掌握

fn main() {
    let price: f64 = 299.0;      // 一件衣服 299 元
    let quantity: i32 = 3;        // 买了 3 件
    let is_member: bool = true;   // 是会员

    // 一次表达式算清所有折扣
    let total = (price * quantity as f64)           // 原价
        * if quantity >= 3 { 0.7 } else { 0.9 }    // 数量折扣
        * if is_member { 0.95 } else { 1.0 };      // 会员折扣

    println!("原价: {:.2} 元", price * quantity as f64);
    println!("折后价: {:.2} 元", total);
    println!("节省: {:.2} 元", price * quantity as f64 - total);
}

let a = 10;
let b = 20;
println!("{}", a == b);  // false
println!("{}", a != b);  // true
println!("{}", a < b);   // true

fn main() {
    let y = {
        let x = 3;
        x + 1       // 没有分号——这是表达式，返回 4
    };               // 分号结束 let 语句

    println!("y 的值: {}", y);  // 4
}

let result = {
    let a = 2;
    let b = 3;
    a * b           // 不加分号，此块表达式返回 6
};

// ============================================
// 算术运算符演示——注意整数除法截断
// ============================================

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!("浮点除法: {} / {} = {:.2}", a as f64, b as f64, a as f64 / b as f64);
    println!("取余: {} % {} = {}", a, b, a % b);
}

加法: 10 + 3 = 13
减法: 10 - 3 = 7
乘法: 10 * 3 = 30
整数除法: 10 / 3 = 3 (截断)
浮点除法: 10 / 3 = 3.33
取余: 10 % 3 = 1

// ============================================
// 逻辑运算符的短路求值特性
// ============================================

fn main() {
    let age = 17;
    let has_id = true;

    // && 短路：左侧 false 则右侧不执行
    let can_buy = age >= 18 && has_id;
    println!("可以购买（&&）: {}", can_buy);  // false（因为左侧已 false）

    // || 短路：左侧 true 则右侧不执行
    let is_ok = true || (expensive_check());
    println!("(|| 短路，右侧不会执行): {}", is_ok);
}

fn expensive_check() -> bool {
    println!("这个函数不会被执行！");
    true
}

可以购买（&&）: false
(|| 短路，右侧不会执行): true

// ============================================
// 用表达式块实现复杂条件的简洁赋值
// ============================================

fn main() {
    let score = 85;

    let grade = {
        if score >= 90 {
            "A"
        } else if score >= 80 {
            "B"
        } else if score >= 70 {
            "C"
        } else if score >= 60 {
            "D"
        } else {
            "F"
        }
    };  // 注意：整个 if-else 链是一个表达式，用分号结束 let 语句

    println!("分数: {}, 等级: {}", score, grade);

    // 三元运算的替代：用 if 表达式
    let is_pass = if score >= 60 { "passed" } else { "failed" };
    println!("结果: {}", is_pass);
}

分数: 85, 等级: B
结果: passed

// ============================================
// 位运算实战：文件权限和 RGB 颜色操作
// ============================================

fn main() {
    let read_perm: u8    = 0b100;   // 4
    let write_perm: u8   = 0b010;   // 2
    let exec_perm: u8    = 0b001;   // 1

    let user_perm = read_perm | write_perm;
    println!("用户权限: {:03b} (读+写)", user_perm);

    let full_perm = read_perm | write_perm | exec_perm;
    println!("完整权限: {:03b} (读+写+执行)", full_perm);

    let can_read = (user_perm & read_perm) != 0;
    let can_exec = (user_perm & exec_perm) != 0;
    println!("用户可读: {}，可执行: {}", can_read, can_exec);

    let no_write = user_perm & !write_perm;
    println!("移除写权限: {:03b}", no_write);

    let toggled = user_perm ^ exec_perm;
    println!("切换执行位: {:03b}", toggled);

    let red: u32   = 0xFF0000;
    let green: u32 = 0x00FF00;
    let blue: u32  = 0x0000FF;
    let yellow = red | green;
    let white = red | green | blue;
    println!("\n红色: {:06X}", red);
    println!("黄色 (红|绿): {:06X}", yellow);
    println!("白色 (红|绿|蓝): {:06X}", white);

    let pixel: u32 = 0xFF8040;
    let r = (pixel >> 16) & 0xFF;
    let g = (pixel >> 8)  & 0xFF;
    let b = pixel & 0xFF;
    println!("\n像素 #FF8040 → R={}, G={}, B={}", r, g, b);

    let shift_val: u8 = 1;
    println!("\n1 << 0 = {}", shift_val << 0);
    println!("1 << 1 = {}", shift_val << 1);
    println!("1 << 2 = {}", shift_val << 2);
    println!("1 << 3 = {}", shift_val << 3);
}

用户权限: 110 (读+写)
完整权限: 111 (读+写+执行)
用户可读: true，可执行: false
移除写权限: 100
切换执行位: 111

红色: FF0000
黄色 (红|绿): FFFF00
白色 (红|绿|蓝): FFFFFF

像素 #FF8040 → R=255, G=128, B=64

1 << 0 = 1
1 << 1 = 2
1 << 2 = 4
1 << 3 = 8

// ============================================
// 运算符优先级实战 + 复合赋值运算符
// ============================================

fn main() {
    println!("=== 运算符优先级 ===");
    let a = 2 + 3 * 4;
    println!("2 + 3 * 4 = {} (先乘后加)", a);

    let b = (2 + 3) * 4;
    println!("(2 + 3) * 4 = {} (括号优先)", b);

    let c = 10 - 6 / 2;
    println!("10 - 6 / 2 = {} (先除后减)", c);

    let d = true && false || true;
    println!("true && false || true = {} (&& 优先于 ||)", d);

    let e = true || false && false;
    println!("true || false && false = {} (&& 优先于 ||)", e);

    println!("\n=== 复合赋值运算符 ===");
    let mut score: i32 = 100;
    score += 20;
    println!("score += 20 → {}", score);
    score -= 30;
    println!("score -= 30 → {}", score);
    score *= 2;
    println!("score *= 2 → {}", score);
    score /= 7;
    println!("score /= 7 → {}", score);
    score %= 3;
    println!("score %= 3 → {}", score);

    println!("\n=== 链式比较（用逻辑运算符）===");
    let x = 50;
    let in_range = x >= 0 && x <= 100;
    let out_range = x < 0 || x > 100;
    println!("x={}, 在[0,100]内: {}, 在外: {}", x, in_range, out_range);

    let charlie_score = 75;
    let bob_score = 88;
    let both_passed = charlie_score >= 60 && bob_score >= 60;
    let any_excellent = charlie_score >= 90 || bob_score >= 90;
    println!("两人都及格: {}, 有人优秀: {}", both_passed, any_excellent);
}

=== 运算符优先级 ===
2 + 3 * 4 = 14 (先乘后加)
(2 + 3) * 4 = 20 (括号优先)
10 - 6 / 2 = 7 (先除后减)
true && false || true = true (&& 优先于 ||)
true || false && false = true (&& 优先于 ||)

=== 复合赋值运算符 ===
score += 20 → 120
score -= 30 → 90
score *= 2 → 180
score /= 7 → 25
score %= 3 → 1

=== 链式比较（用逻辑运算符）===
x=50, 在[0,100]内: true, 在外: false
两人都及格: true, 有人优秀: false