📚 第3章：基本语法

本章目标

通过本章学习，你将掌握： - Rust的变量声明和可变性 - Rust的数据类型系统 - 函数的定义和调用 - 控制流语句 - 表达式和语句的区别 - 注释和文档

3.1 变量和可变性

变量声明

Rust中的变量默认是不可变的（immutable），这是Rust安全性的重要特性。

fn main() {
    println!("🔧 Rust变量基础");
    println!("===============");
    
    // 不可变变量
    let x = 5;
    println!("x的值: {}", x);
    
    // x = 6; // 这行会编译错误！
    
    // 可变变量
    let mut y = 5;
    println!("y的初始值: {}", y);
    
    y = 6;
    println!("y的新值: {}", y);
    
    // 常量
    const MAX_POINTS: u32 = 100_000;
    println!("最大分数: {}", MAX_POINTS);
}

rustc variables_basic.rs && ./variables_basic

变量遮蔽（Shadowing）

fn main() {
    println!("👥 变量遮蔽示例");
    println!("===============");
    
    let x = 5;
    println!("第一个x: {}", x);
    
    let x = x + 1;  // 遮蔽前一个x
    println!("第二个x: {}", x);
    
    {
        let x = x * 2;  // 在内部作用域遮蔽
        println!("内部作用域的x: {}", x);
    }
    
    println!("外部作用域的x: {}", x);
    
    // 遮蔽可以改变类型
    let spaces = "   ";
    let spaces = spaces.len();
    println!("空格数量: {}", spaces);
}

rustc shadowing.rs && ./shadowing

常量和静态变量

// 全局常量
const PI: f64 = 3.14159265359;
const MAX_USERS: usize = 1000;

// 静态变量
static LANGUAGE: &str = "Rust";
static mut COUNTER: usize = 0;

fn main() {
    println!("📊 常量和静态变量");
    println!("==================");
    
    println!("π的值: {}", PI);
    println!("最大用户数: {}", MAX_USERS);
    println!("编程语言: {}", LANGUAGE);
    
    // 访问可变静态变量需要unsafe
    unsafe {
        COUNTER += 1;
        println!("计数器: {}", COUNTER);
    }
    
    // 局部常量
    const LOCAL_CONST: i32 = 42;
    println!("局部常量: {}", LOCAL_CONST);
}

rustc constants.rs && ./constants

3.2 数据类型

标量类型

整数类型

fn main() {
    println!("🔢 整数类型示例");
    println!("===============");
    
    // 有符号整数
    let i8_val: i8 = -128;
    let i16_val: i16 = -32_768;
    let i32_val: i32 = -2_147_483_648;
    let i64_val: i64 = -9_223_372_036_854_775_808;
    let i128_val: i128 = -170_141_183_460_469_231_731_687_303_715_884_105_728;
    let isize_val: isize = -1000;
    
    println!("i8: {}", i8_val);
    println!("i16: {}", i16_val);
    println!("i32: {}", i32_val);
    println!("i64: {}", i64_val);
    println!("i128: {}", i128_val);
    println!("isize: {}", isize_val);
    
    // 无符号整数
    let u8_val: u8 = 255;
    let u16_val: u16 = 65_535;
    let u32_val: u32 = 4_294_967_295;
    let u64_val: u64 = 18_446_744_073_709_551_615;
    let u128_val: u128 = 340_282_366_920_938_463_463_374_607_431_768_211_455;
    let usize_val: usize = 1000;
    
    println!("\nu8: {}", u8_val);
    println!("u16: {}", u16_val);
    println!("u32: {}", u32_val);
    println!("u64: {}", u64_val);
    println!("u128: {}", u128_val);
    println!("usize: {}", usize_val);
    
    // 不同进制表示
    let decimal = 98_222;
    let hex = 0xff;
    let octal = 0o77;
    let binary = 0b1111_0000;
    let byte = b'A';
    
    println!("\n不同进制:");
    println!("十进制: {}", decimal);
    println!("十六进制: {}", hex);
    println!("八进制: {}", octal);
    println!("二进制: {}", binary);
    println!("字节: {}", byte);
}

rustc integer_types.rs && ./integer_types

浮点类型

fn main() {
    println!("🔢 浮点类型示例");
    println!("===============");
    
    let f32_val: f32 = 3.14159;
    let f64_val: f64 = 2.718281828459045;
    
    println!("f32: {}", f32_val);
    println!("f64: {}", f64_val);
    
    // 浮点运算
    let sum = f32_val + 1.0;
    let difference = f64_val - 1.0;
    let product = f32_val * 2.0;
    let quotient = f64_val / 2.0;
    
    println!("\n浮点运算:");
    println!("{} + 1.0 = {}", f32_val, sum);
    println!("{} - 1.0 = {}", f64_val, difference);
    println!("{} * 2.0 = {}", f32_val, product);
    println!("{} / 2.0 = {}", f64_val, quotient);
    
    // 特殊值
    let infinity = f64::INFINITY;
    let neg_infinity = f64::NEG_INFINITY;
    let nan = f64::NAN;
    
    println!("\n特殊值:");
    println!("正无穷: {}", infinity);
    println!("负无穷: {}", neg_infinity);
    println!("NaN: {}", nan);
    println!("NaN是否等于自己: {}", nan == nan);  // false!
}

rustc float_types.rs && ./float_types

布尔类型

fn main() {
    println!("✅ 布尔类型示例");
    println!("===============");
    
    let is_rust_awesome = true;
    let is_learning_hard: bool = false;
    
    println!("Rust很棒吗? {}", is_rust_awesome);
    println!("学习困难吗? {}", is_learning_hard);
    
    // 布尔运算
    let and_result = is_rust_awesome && !is_learning_hard;
    let or_result = is_rust_awesome || is_learning_hard;
    let not_result = !is_learning_hard;
    
    println!("\n布尔运算:");
    println!("{} && {} = {}", is_rust_awesome, !is_learning_hard, and_result);
    println!("{} || {} = {}", is_rust_awesome, is_learning_hard, or_result);
    println!("!{} = {}", is_learning_hard, not_result);
    
    // 条件表达式
    let message = if is_rust_awesome {
        "继续学习Rust!"
    } else {
        "考虑其他语言"
    };
    
    println!("建议: {}", message);
}

rustc boolean_type.rs && ./boolean_type

字符类型

fn main() {
    println!("🔤 字符类型示例");
    println!("===============");
    
    let c = 'z';
    let z = 'ℤ';
    let heart_eyed_cat = '😻';
    let chinese_char = '中';
    
    println!("英文字符: {}", c);
    println!("数学符号: {}", z);
    println!("表情符号: {}", heart_eyed_cat);
    println!("中文字符: {}", chinese_char);
    
    // 字符的Unicode值
    println!("\nUnicode值:");
    println!("'{}' = U+{:04X}", c, c as u32);
    println!("'{}' = U+{:04X}", z, z as u32);
    println!("'{}' = U+{:04X}", heart_eyed_cat, heart_eyed_cat as u32);
    println!("'{}' = U+{:04X}", chinese_char, chinese_char as u32);
    
    // 转义字符
    let newline = '\n';
    let tab = '\t';
    let backslash = '\\';
    let quote = '\'';
    
    println!("\n转义字符:");
    println!("换行符: {:?}", newline);
    println!("制表符: {:?}", tab);
    println!("反斜杠: {:?}", backslash);
    println!("单引号: {:?}", quote);
}

rustc char_type.rs && ./char_type

复合类型

元组类型

fn main() {
    println!("📦 元组类型示例");
    println!("===============");
    
    // 创建元组
    let tup: (i32, f64, u8) = (500, 6.4, 1);
    println!("元组: {:?}", tup);
    
    // 解构元组
    let (x, y, z) = tup;
    println!("解构后: x={}, y={}, z={}", x, y, z);
    
    // 通过索引访问
    let first = tup.0;
    let second = tup.1;
    let third = tup.2;
    
    println!("索引访问: {}, {}, {}", first, second, third);
    
    // 不同类型的元组
    let mixed = ("hello", 42, true, 3.14);
    println!("混合类型元组: {:?}", mixed);
    
    // 单元素元组
    let single = (42,);  // 注意逗号
    println!("单元素元组: {:?}", single);
    
    // 空元组（单元类型）
    let unit = ();
    println!("空元组: {:?}", unit);
    
    // 嵌套元组
    let nested = ((1, 2), (3, 4));
    println!("嵌套元组: {:?}", nested);
    println!("访问嵌套元素: {}", nested.0.1);
}

rustc tuple_type.rs && ./tuple_type

数组类型

fn main() {
    println!("📊 数组类型示例");
    println!("===============");
    
    // 创建数组
    let arr1 = [1, 2, 3, 4, 5];
    println!("数组1: {:?}", arr1);
    
    // 指定类型和长度
    let arr2: [i32; 5] = [1, 2, 3, 4, 5];
    println!("数组2: {:?}", arr2);
    
    // 初始化相同值
    let arr3 = [3; 5];  // [3, 3, 3, 3, 3]
    println!("数组3: {:?}", arr3);
    
    // 访问数组元素
    let first = arr1[0];
    let second = arr1[1];
    println!("第一个元素: {}", first);
    println!("第二个元素: {}", second);
    
    // 数组长度
    println!("数组长度: {}", arr1.len());
    
    // 遍历数组
    println!("\n遍历数组:");
    for element in arr1.iter() {
        println!("元素: {}", element);
    }
    
    // 带索引遍历
    println!("\n带索引遍历:");
    for (index, element) in arr1.iter().enumerate() {
        println!("索引{}: {}", index, element);
    }
    
    // 数组切片
    let slice = &arr1[1..4];
    println!("\n切片 [1..4]: {:?}", slice);
    
    // 多维数组
    let matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
    println!("\n矩阵: {:?}", matrix);
    println!("矩阵元素 [1][2]: {}", matrix[1][2]);
}

rustc array_type.rs && ./array_type

3.3 函数

函数定义和调用

fn main() {
    println!("🔧 函数基础示例");
    println!("===============");
    
    // 调用函数
    greet();
    greet_person("Alice");
    
    let result = add(5, 3);
    println!("5 + 3 = {}", result);
    
    let (sum, product) = calculate(4, 6);
    println!("4 + 6 = {}, 4 * 6 = {}", sum, product);
    
    // 函数作为表达式
    let value = {
        let x = 3;
        let y = 4;
        add(x, y)  // 注意没有分号
    };
    println!("表达式结果: {}", value);
}

// 无参数无返回值函数
fn greet() {
    println!("Hello, World!");
}

// 有参数无返回值函数
fn greet_person(name: &str) {
    println!("Hello, {}!", name);
}

// 有参数有返回值函数
fn add(a: i32, b: i32) -> i32 {
    a + b  // 表达式，没有分号
}

// 多个返回值（使用元组）
fn calculate(a: i32, b: i32) -> (i32, i32) {
    (a + b, a * b)
}

rustc functions_basic.rs && ./functions_basic

函数参数和返回值

fn main() {
    println!("📝 函数参数示例");
    println!("===============");
    
    // 基本参数
    let result1 = multiply(4, 5);
    println!("4 * 5 = {}", result1);
    
    // 引用参数
    let text = String::from("Hello");
    let length = get_length(&text);
    println!("'{}' 的长度: {}", text, length);
    
    // 可变引用参数
    let mut number = 10;
    double_value(&mut number);
    println!("翻倍后的值: {}", number);
    
    // 数组参数
    let arr = [1, 2, 3, 4, 5];
    let sum = sum_array(&arr);
    println!("数组和: {}", sum);
    
    // 元组参数
    let point = (3, 4);
    let distance = distance_from_origin(point);
    println!("点 {:?} 到原点的距离: {:.2}", point, distance);
    
    // 多种返回方式
    let (min, max) = min_max(&arr);
    println!("最小值: {}, 最大值: {}", min, max);
    
    let maybe_first = get_first(&arr);
    match maybe_first {
        Some(value) => println!("第一个元素: {}", value),
        None => println!("数组为空"),
    }
}

// 基本参数
fn multiply(x: i32, y: i32) -> i32 {
    x * y
}

// 引用参数（借用）
fn get_length(s: &String) -> usize {
    s.len()
}

// 可变引用参数
fn double_value(x: &mut i32) {
    *x *= 2;
}

// 数组切片参数
fn sum_array(arr: &[i32]) -> i32 {
    let mut sum = 0;
    for &item in arr {
        sum += item;
    }
    sum
}

// 元组参数
fn distance_from_origin(point: (i32, i32)) -> f64 {
    let (x, y) = point;
    ((x * x + y * y) as f64).sqrt()
}

// 返回元组
fn min_max(arr: &[i32]) -> (i32, i32) {
    let mut min = arr[0];
    let mut max = arr[0];
    
    for &item in arr {
        if item < min {
            min = item;
        }
        if item > max {
            max = item;
        }
    }
    
    (min, max)
}

// 返回Option
fn get_first(arr: &[i32]) -> Option<i32> {
    if arr.is_empty() {
        None
    } else {
        Some(arr[0])
    }
}

rustc function_parameters.rs && ./function_parameters

语句和表达式

fn main() {
    println!("📋 语句和表达式");
    println!("===============");
    
    // 语句（statements）- 不返回值
    let x = 5;  // 这是一个语句
    let y = 6;  // 这也是一个语句
    
    // 表达式（expressions）- 返回值
    let z = {
        let a = 3;
        let b = 4;
        a + b  // 这是表达式，注意没有分号
    };
    
    println!("x = {}, y = {}, z = {}", x, y, z);
    
    // 函数调用是表达式
    let result = add_one(5);
    println!("add_one(5) = {}", result);
    
    // if是表达式
    let condition = true;
    let number = if condition { 5 } else { 6 };
    println!("条件表达式结果: {}", number);
    
    // 循环也可以是表达式
    let mut counter = 0;
    let loop_result = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2;  // break可以返回值
        }
    };
    println!("循环表达式结果: {}", loop_result);
    
    // match是表达式
    let value = 3;
    let description = match value {
        1 => "one",
        2 => "two",
        3 => "three",
        _ => "other",
    };
    println!("match表达式结果: {}", description);
}

fn add_one(x: i32) -> i32 {
    x + 1  // 表达式，作为返回值
}

rustc statements_expressions.rs && ./statements_expressions

3.4 控制流

if表达式

fn main() {
    println!("🔀 if表达式示例");
    println!("===============");
    
    let number = 6;
    
    // 基本if
    if number < 5 {
        println!("数字小于5");
    } else {
        println!("数字大于等于5");
    }
    
    // else if
    if number % 4 == 0 {
        println!("数字能被4整除");
    } else if number % 3 == 0 {
        println!("数字能被3整除");
    } else if number % 2 == 0 {
        println!("数字能被2整除");
    } else {
        println!("数字不能被4、3或2整除");
    }
    
    // if作为表达式
    let condition = true;
    let value = if condition { 5 } else { 6 };
    println!("条件表达式的值: {}", value);
    
    // 复杂条件
    let age = 18;
    let has_license = true;
    
    if age >= 18 && has_license {
        println!("可以开车");
    } else if age >= 18 {
        println!("年龄够了，但需要驾照");
    } else {
        println!("年龄不够");
    }
    
    // 嵌套if
    let weather = "sunny";
    let temperature = 25;
    
    if weather == "sunny" {
        if temperature > 20 {
            println!("完美的天气！");
        } else {
            println!("阳光明媚但有点冷");
        }
    } else {
        println!("天气不太好");
    }
}

rustc if_expressions.rs && ./if_expressions

循环

loop循环

fn main() {
    println!("🔄 loop循环示例");
    println!("===============");
    
    // 基本loop
    let mut counter = 0;
    
    loop {
        counter += 1;
        println!("计数: {}", counter);
        
        if counter == 3 {
            break;
        }
    }
    
    // loop作为表达式
    let mut count = 0;
    let result = loop {
        count += 1;
        
        if count == 10 {
            break count * 2;  // 返回值
        }
    };
    println!("loop表达式结果: {}", result);
    
    // 嵌套循环和标签
    let mut outer_count = 0;
    
    'outer: loop {
        outer_count += 1;
        println!("外层循环: {}", outer_count);
        
        let mut inner_count = 0;
        
        loop {
            inner_count += 1;
            println!("  内层循环: {}", inner_count);
            
            if inner_count == 2 {
                break;  // 只跳出内层循环
            }
            
            if outer_count == 2 {
                break 'outer;  // 跳出外层循环
            }
        }
    }
    
    println!("循环结束");
}

rustc loop_examples.rs && ./loop_examples

while循环

fn main() {
    println!("🔄 while循环示例");
    println!("=================");
    
    // 基本while循环
    let mut number = 3;
    
    while number != 0 {
        println!("倒计时: {}", number);
        number -= 1;
    }
    println!("发射！");
    
    // 条件循环
    let mut count = 0;
    while count < 5 {
        count += 1;
        println!("计数: {}", count);
    }
    
    // 使用while遍历数组（不推荐）
    let arr = [10, 20, 30, 40, 50];
    let mut index = 0;
    
    println!("\n使用while遍历数组:");
    while index < arr.len() {
        println!("索引{}: {}", index, arr[index]);
        index += 1;
    }
    
    // 复杂条件
    let mut x = 1;
    let mut y = 1;
    
    println!("\n斐波那契数列（前10项）:");
    let mut count = 0;
    while count < 10 {
        println!("{}", x);
        let temp = x + y;
        x = y;
        y = temp;
        count += 1;
    }
}

rustc while_examples.rs && ./while_examples

for循环

fn main() {
    println!("🔄 for循环示例");
    println!("===============");
    
    // 遍历数组
    let arr = [10, 20, 30, 40, 50];
    
    println!("遍历数组:");
    for element in arr.iter() {
        println!("元素: {}", element);
    }
    
    // 带索引遍历
    println!("\n带索引遍历:");
    for (index, element) in arr.iter().enumerate() {
        println!("索引{}: {}", index, element);
    }
    
    // 遍历范围
    println!("\n遍历范围 1..5:");
    for number in 1..5 {
        println!("数字: {}", number);
    }
    
    println!("\n遍历范围 1..=5:");
    for number in 1..=5 {
        println!("数字: {}", number);
    }
    
    // 反向遍历
    println!("\n反向遍历:");
    for number in (1..5).rev() {
        println!("数字: {}", number);
    }
    
    // 遍历字符串
    let text = "hello";
    println!("\n遍历字符串字符:");
    for ch in text.chars() {
        println!("字符: {}", ch);
    }
    
    // 遍历字符串字节
    println!("\n遍历字符串字节:");
    for byte in text.bytes() {
        println!("字节: {}", byte);
    }
    
    // 嵌套for循环
    println!("\n乘法表:");
    for i in 1..=3 {
        for j in 1..=3 {
            print!("{} * {} = {}\t", i, j, i * j);
        }
        println!();
    }
}

rustc for_examples.rs && ./for_examples

match表达式

fn main() {
    println!("🎯 match表达式示例");
    println!("==================");
    
    // 基本match
    let number = 3;
    
    match number {
        1 => println!("一"),
        2 => println!("二"),
        3 => println!("三"),
        4 => println!("四"),
        _ => println!("其他"),  // 默认分支
    }
    
    // match作为表达式
    let value = match number {
        1 => "one",
        2 => "two",
        3 => "three",
        _ => "other",
    };
    println!("数字{}对应: {}", number, value);
    
    // 匹配范围
    let score = 85;
    let grade = match score {
        90..=100 => "A",
        80..=89 => "B",
        70..=79 => "C",
        60..=69 => "D",
        _ => "F",
    };
    println!("分数{}对应等级: {}", score, grade);
    
    // 匹配多个值
    let day = 3;
    let day_type = match day {
        1 | 2 | 3 | 4 | 5 => "工作日",
        6 | 7 => "周末",
        _ => "无效日期",
    };
    println!("第{}天是: {}", day, day_type);
    
    // 匹配元组
    let point = (0, 5);
    match point {
        (0, 0) => println!("原点"),
        (0, y) => println!("在Y轴上，y = {}", y),
        (x, 0) => println!("在X轴上，x = {}", x),
        (x, y) => println!("点({}, {})", x, y),
    }
    
    // 匹配Option
    let maybe_number = Some(5);
    match maybe_number {
        Some(value) => println!("有值: {}", value),
        None => println!("没有值"),
    }
    
    // 守卫条件
    let num = Some(4);
    match num {
        Some(x) if x < 5 => println!("小于5的数: {}", x),
        Some(x) => println!("大于等于5的数: {}", x),
        None => println!("没有数"),
    }
}

rustc match_examples.rs && ./match_examples

3.5 注释和文档

注释类型

// 这是单行注释

/*
这是多行注释
可以跨越多行
*/

/// 这是文档注释，用于函数、结构体等
/// 
/// # 参数
/// 
/// * `name` - 要问候的人的名字
/// 
/// # 示例
/// 
/// ```
/// greet_with_doc("Alice");
/// ```
fn greet_with_doc(name: &str) {
    println!("Hello, {}!", name);
}

/**
 * 这也是文档注释（块风格）
 * 
 * 计算两个数的和
 */
fn add_with_doc(a: i32, b: i32) -> i32 {
    a + b
}

fn main() {
    println!("📝 注释示例");
    println!("============");
    
    // 调用带文档的函数
    greet_with_doc("Rust");
    
    let result = add_with_doc(3, 4);
    println!("3 + 4 = {}", result);
    
    /* 
    这里可以写多行注释
    解释复杂的逻辑
    */
    let complex_calculation = {
        let x = 10; // 基数
        let y = 20; // 乘数
        x * y + 5   // 计算结果
    };
    
    println!("复杂计算结果: {}", complex_calculation);
    
    // TODO: 添加更多功能
    // FIXME: 修复这个bug
    // NOTE: 这里需要注意性能
    
    println!("运行 'cargo doc --open' 查看生成的文档！");
}

rustc comments_examples.rs && ./comments_examples

文档测试

/// 计算矩形面积
/// 
/// # 参数
/// 
/// * `width` - 矩形宽度
/// * `height` - 矩形高度
/// 
/// # 返回值
/// 
/// 返回矩形的面积
/// 
/// # 示例
/// 
/// ```
/// let area = calculate_area(5.0, 3.0);
/// assert_eq!(area, 15.0);
/// ```
/// 
/// ```
/// // 边界情况测试
/// let zero_area = calculate_area(0.0, 5.0);
/// assert_eq!(zero_area, 0.0);
/// ```
fn calculate_area(width: f64, height: f64) -> f64 {
    width * height
}

/// 数学工具模块
/// 
/// 提供基本的数学计算功能
/// 
/// # 示例
/// 
/// ```
/// use doc_tests::math;
/// 
/// let result = math::square(4);
/// assert_eq!(result, 16);
/// ```
pub mod math {
    /// 计算平方
    /// 
    /// # 示例
    /// 
    /// ```
    /// let result = doc_tests::math::square(3);
    /// assert_eq!(result, 9);
    /// ```
    pub fn square(x: i32) -> i32 {
        x * x
    }
    
    /// 计算立方
    pub fn cube(x: i32) -> i32 {
        x * x * x
    }
}

fn main() {
    println!("📚 文档测试示例");
    println!("===============");
    
    let area = calculate_area(5.0, 3.0);
    println!("矩形面积: {}", area);
    
    let square_result = math::square(4);
    println!("4的平方: {}", square_result);
    
    let cube_result = math::cube(3);
    println!("3的立方: {}", cube_result);
    
    println!("运行 'cargo test --doc' 执行文档测试！");
}

rustc doc_tests.rs && ./doc_tests

3.6 综合示例

让我们创建一个综合示例，展示本章学到的所有概念：

/// 学生信息结构
/// 
/// 包含学生的基本信息和成绩
struct Student {
    name: String,
    age: u8,
    grades: [f64; 5],
}

impl Student {
    /// 创建新学生
    fn new(name: String, age: u8, grades: [f64; 5]) -> Student {
        Student { name, age, grades }
    }
    
    /// 计算平均分
    fn average_grade(&self) -> f64 {
        let sum: f64 = self.grades.iter().sum();
        sum / self.grades.len() as f64
    }
    
    /// 获取等级
    fn get_grade_letter(&self) -> char {
        let avg = self.average_grade();
        match avg {
            90.0..=100.0 => 'A',
            80.0..=89.9 => 'B',
            70.0..=79.9 => 'C',
            60.0..=69.9 => 'D',
            _ => 'F',
        }
    }
    
    /// 是否及格
    fn is_passing(&self) -> bool {
        self.average_grade() >= 60.0
    }
}

/// 计算多个学生的统计信息
fn calculate_class_stats(students: &[Student]) -> (f64, f64, usize) {
    if students.is_empty() {
        return (0.0, 0.0, 0);
    }
    
    let mut total = 0.0;
    let mut passing_count = 0;
    
    for student in students {
        total += student.average_grade();
        if student.is_passing() {
            passing_count += 1;
        }
    }
    
    let class_average = total / students.len() as f64;
    let highest = students
        .iter()
        .map(|s| s.average_grade())
        .fold(0.0, f64::max);
    
    (class_average, highest, passing_count)
}

/// 打印学生信息
fn print_student_info(student: &Student) {
    println!("学生: {}", student.name);
    println!("年龄: {}", student.age);
    println!("成绩: {:?}", student.grades);
    println!("平均分: {:.2}", student.average_grade());
    println!("等级: {}", student.get_grade_letter());
    println!("状态: {}", if student.is_passing() { "及格" } else { "不及格" });
    println!("-".repeat(30));
}

fn main() {
    println!("🎓 学生成绩管理系统");
    println!("====================");
    
    // 创建学生数据
    let students = vec![
        Student::new("Alice".to_string(), 20, [95.0, 87.0, 92.0, 88.0, 91.0]),
        Student::new("Bob".to_string(), 19, [78.0, 82.0, 75.0, 80.0, 79.0]),
        Student::new("Charlie".to_string(), 21, [65.0, 70.0, 68.0, 72.0, 69.0]),
        Student::new("Diana".to_string(), 20, [45.0, 52.0, 48.0, 50.0, 47.0]),
    ];
    
    // 打印每个学生的信息
    for student in &students {
        print_student_info(student);
    }
    
    // 计算班级统计
    let (class_avg, highest, passing) = calculate_class_stats(&students);
    
    println!("📊 班级统计:");
    println!("班级平均分: {:.2}", class_avg);
    println!("最高平均分: {:.2}", highest);
    println!("及格人数: {}/{}", passing, students.len());
    println!("及格率: {:.1}%", (passing as f64 / students.len() as f64) * 100.0);
    
    // 按成绩分类
    println!("\n📈 成绩分布:");
    let mut grade_counts = [0; 5]; // A, B, C, D, F
    
    for student in &students {
        let grade_index = match student.get_grade_letter() {
            'A' => 0,
            'B' => 1,
            'C' => 2,
            'D' => 3,
            'F' => 4,
            _ => 4,
        };
        grade_counts[grade_index] += 1;
    }
    
    let grades = ['A', 'B', 'C', 'D', 'F'];
    for (i, &count) in grade_counts.iter().enumerate() {
        if count > 0 {
            println!("{}: {} 人", grades[i], count);
        }
    }
    
    // 寻找最佳学生
    let best_student = students
        .iter()
        .max_by(|a, b| a.average_grade().partial_cmp(&b.average_grade()).unwrap());
    
    if let Some(student) = best_student {
        println!("\n🏆 最佳学生: {} (平均分: {:.2})", 
                student.name, student.average_grade());
    }
    
    // 需要帮助的学生
    println!("\n⚠️ 需要帮助的学生:");
    for student in &students {
        if !student.is_passing() {
            println!("- {} (平均分: {:.2})", student.name, student.average_grade());
        }
    }
}

rustc comprehensive_example.rs && ./comprehensive_example

本章小结

通过本章学习，你应该掌握了：

✅ 变量和可变性: let、mut、const、变量遮蔽 ✅ 数据类型: 标量类型（整数、浮点、布尔、字符）和复合类型（元组、数组） ✅ 函数: 函数定义、参数、返回值、语句和表达式 ✅ 控制流: if表达式、loop、while、for循环、match表达式 ✅ 注释: 单行注释、多行注释、文档注释、文档测试

下一章预告

在下一章《所有权系统》中，我们将学习Rust最重要的概念：

• 所有权规则和原理
• 借用和引用
• 切片类型
• 内存管理机制
• 移动和复制语义

练习题

练习1：温度转换器

编写一个程序，实现摄氏度和华氏度之间的转换。

练习2：猜数字游戏

创建一个猜数字游戏，程序生成1-100之间的随机数，用户猜测，程序给出提示。

练习3：斐波那契数列

编写函数计算斐波那契数列的第n项，分别用递归和迭代两种方法实现。

练习4：数组操作

编写函数对数组进行各种操作：求和、求平均值、找最大值、找最小值、排序。

---

恭喜你掌握了Rust的基本语法！ 🎉

现在你已经具备了编写简单Rust程序的能力，接下来让我们深入学习Rust的核心特性——所有权系统！