fn main() {
    let a: i32 = -42;      // 有符号，可以是负数
    let b: u32 = 100;      // 无符号，只能非负
    let c: u8  = 255;      // u8 最大值
    let d: i64 = 9_999_999_999; // 大数用下划线分隔，更易读

    println!("a={} b={} c={} d={}", a, b, c, d);
}

fn main() {
    let x = 3.14;          // 默认 f64
    let y: f32 = 2.0;      // 显式指定 f32
    let z = 1.0_f64;       // 用后缀指定类型

    println!("{} {} {}", x, y, z);

    // 浮点运算
    println!("圆面积 = {:.4}", 3.14159 * 2.0_f64 * 2.0_f64);
}

fn main() {
    let is_active: bool = true;
    let is_empty = false; // 类型推断

    println!("active: {}, empty: {}", is_active, is_empty);
    println!("AND: {}, OR: {}, NOT: {}",
             is_active && is_empty,
             is_active || is_empty,
             !is_active);
}

fn main() {
    let c1 = 'A';
    let c2 = '中';     // 汉字也是合法的 char
    let c3 = '😀';    // 表情符号同样可以
    let c4 = '\n';     // 转义字符

    println!("{} {} {} (换行在这里{})", c1, c2, c3, c4);
}

fn main() {
    let decimal     = 255;          // 十进制
    let hex         = 0xFF;         // 十六进制（0x 前缀）
    let octal       = 0o377;        // 八进制（0o 前缀）
    let binary      = 0b1111_1111;  // 二进制（0b 前缀）
    let million     = 1_000_000;    // 下划线只是视觉分隔符
    let byte: u8    = b'A';         // 字节字面量，等价于 65u8

    // 类型后缀：直接写在数字后面指定类型
    let typed: u32  = 255u32;
    let also_typed  = 255_u8;       // 下划线可以放在后缀前

    println!("{} {} {} {} {} {} {} {}",
             decimal, hex, octal, binary, million, byte, typed, also_typed);
}

fn main() {
    let t = (1i32, true, 'x', 3.14f64);

    // 用 .索引 访问元素（注意：是 .0 不是 [0]）
    println!("第一个: {}", t.0);
    println!("第二个: {}", t.1);

    // 整个元组用 {:?} 打印
    println!("完整元组: {:?}", t);
}

fn min_max(numbers: &[i32]) -> (i32, i32) {
    // 函数返回元组，实现多返回值
    (numbers.iter().copied().min().unwrap(),
     numbers.iter().copied().max().unwrap())
}

fn main() {
    let point = (10, 20);
    let (x, y) = point;  // 解构：把 10 绑定给 x，20 绑定给 y
    println!("x={}, y={}", x, y);

    // 元组作为多返回值
    let nums = [3, 1, 4, 1, 5, 9, 2, 6];
    let (min, max) = min_max(&nums);
    println!("最小值={}, 最大值={}", min, max);

    // 只有一个元素的元组需要尾随逗号以区分括号表达式
    let single = (42,);
    println!("单元素元组: {:?}", single);
    println!("这只是括号: {:?}", (42)); // 这是 i32，不是元组
}

fn main() {
    // 类型标注格式：[元素类型; 长度]
    let xs: [i32; 5] = [1, 2, 3, 4, 5];

    // 用相同值初始化：[初始值; 长度]
    let zeros: [i32; 3] = [0; 3];  // [0, 0, 0]

    println!("第一个: {}", xs[0]);
    println!("最后一个: {}", xs[xs.len() - 1]);
    println!("长度: {}", xs.len());
    println!("zeros: {:?}", zeros);

    // 越界访问会 panic（运行时错误）
    // println!("{}", xs[10]);  // panic: index out of bounds
}

fn sum_slice(slice: &[i32]) -> i32 {
    // 函数接受切片，可以处理任意长度的数组
    slice.iter().sum()
}

fn main() {
    let arr = [1, 2, 3, 4, 5];

    // 借用整个数组为切片
    let all: &[i32] = &arr;
    println!("全部: {:?}, 长度: {}", all, all.len());

    // 借用数组的一部分（半开区间 [1, 4)，即索引 1、2、3）
    let part = &arr[1..4];
    println!("部分: {:?}", part);

    // 函数可以接受任意长度的切片
    println!("全部的和: {}", sum_slice(&arr));
    println!("部分的和: {}", sum_slice(&arr[1..4]));
}

fn main() {
    // 算术运算
    println!("5 + 3 = {}", 5i32 + 3);
    println!("5 - 3 = {}", 5i32 - 3);
    println!("1 - 2 = {}", 1i32 - 2);  // 有符号才能得到负数

    // 整数除法：结果向零截断（不是向下取整）
    println!("5 / 2 = {}", 5i32 / 2);   // 2，不是 2.5
    println!("2 / 3 = {}", 2i32 / 3);   // 0！注意这个陷阱
    println!("43 % 5 = {}", 43i32 % 5); // 取余 = 3

    // 布尔运算（短路求值）
    println!("true && false = {}", true && false);
    println!("true || false = {}", true || false);

    // 位运算
    println!("0b0011 & 0b0101 = {:04b}", 0b0011u32 & 0b0101);  // AND
    println!("0b0011 | 0b0101 = {:04b}", 0b0011u32 | 0b0101);  // OR
    println!("0b0011 ^ 0b0101 = {:04b}", 0b0011u32 ^ 0b0101);  // XOR
    println!("1 << 3 = {}", 1u32 << 3);   // 左移
    println!("16 >> 2 = {}", 16u32 >> 2); // 右移
}

fn main() {
    // 乘除优先于加减（和数学一样）
    println!("{}", 2 + 3 * 4);     // 14，不是 20

    // 位运算优先级低于算术，常需括号
    println!("{}", 1 + 2 & 3);     // 先算 1+2=3，再 3&3=3
    println!("{}", 1 + (2 & 3));   // 先算 2&3=2，再 1+2=3（不同！）

    // 比较运算符优先级低于算术
    println!("{}", 2 + 3 > 4);     // 先算 2+3=5，再 5>4=true

    // 逻辑与优先于逻辑或
    println!("{}", true || false && false); // 先算 false&&false=false，再 true||false=true

    // as 类型转换优先级较高
    let x = 3.99_f64 as i32 + 1;   // 先 as：3.99→3，再 3+1=4
    println!("{}", x);
}

fn main() {
    let a = 5;
    let b = 3;
    let c = 2;

    // 不清晰：读者要记忆优先级
    let r1 = a + b * c & 0xFF;

    // 清晰：括号明确每步意图
    let r2 = (a + (b * c)) & 0xFF;

    println!("{} {}", r1, r2); // 结果相同，但 r2 的写法更易维护
}