====== 数据类型与函数 ======

===== 原生数据类型 =====

==== 整数类型 ====

^ 长度 ^ 有符号 ^ 无符号 ^
| 8位 | ''i8'' | ''u8'' |
| 16位 | ''i16'' | ''u16'' |
| 32位 | ''i32'' | ''u32'' |
| 64位 | ''i64'' | ''u64'' |
| 128位 | ''i128'' | ''u128'' |
| 架构相关 | ''isize'' | ''usize'' |

默认整数类型是 ''i32''。

<code rust>
let a: i8 = -128;         // -128 到 127
let b: u8 = 255;           // 0 到 255
let c = 42;                // 默认 i32
let d: i64 = 9_223_372_036_854_775_807; // 下划线提高可读性
let e: usize = 10;         // 指针宽度，用于索引
</code>

==== 浮点类型 ====

<code rust>
let x: f32 = 3.14;         // 32 位浮点
let y: f64 = 3.1415926535; // 64 位浮点（默认）
</code>

==== 布尔类型 ====

<code rust>
let is_ok: bool = true;
let is_not: bool = false;
</code>

==== 字符类型 ====

''char'' 是 4 字节的 Unicode 标量值：

<code rust>
let c = '中';           // Unicode 字符
let emoji = '😊';       // 表情符号
let letter = 'A';
</code>

===== 复合类型 =====

==== 元组（Tuple） ====

固定长度的异构集合：

<code rust>
let tup: (i32, f64, char) = (42, 3.14, 'R');

// 解构（destructure）
let (x, y, z) = tup;
println!("{}, {}, {}", x, y, z);

// 索引访问
println!("{}", tup.0);  // 42
println!("{}", tup.1);  // 3.14
</code>

==== 数组（Array） ====

固定长度的同构集合（栈上分配）：

<code rust>
let arr: [i32; 5] = [1, 2, 3, 4, 5];
let zeros = [0; 3];       // [0, 0, 0]

println!("{}", arr[0]);   // 1
println!("len: {}", arr.len()); // 5
</code>

访问越界索引会导致**运行时 panic**，Rust 会安全地检查边界。

===== 函数 =====

==== 函数定义 ====

<code rust>
fn greet(name: &str) {
    println!("你好，{}！", name);
}

fn main() {
    greet("Rust");
}
</code>

==== 返回值 ====

用 ''->'' 指定返回类型，最后一个表达式即为返回值：

<code rust>
fn add(x: i32, y: i32) -> i32 {
    x + y // 注意：没有分号，是表达式
}

fn double(x: i32) -> i32 {
    return x * 2; // 也可以用 return，但通常省略
}

fn main() {
    println!("{}", add(3, 5));  // 8
    println!("{}", double(4));  // 8
}
</code>

==== 表达式 vs 语句 ====

  * **语句（Statement）** - 执行操作，不返回值，如 ''let x = 5;''
  * **表达式（Expression）** - 计算并返回值，如 ''x + 1''

<code rust>
fn main() {
    let x = {
        let a = 2;
        let b = 3;
        a + b // 代码块作为表达式，返回 5
    };
    println!("{}", x); // 5
}
</code>

==== 发散函数 ====

用 ''!'' 表示永不返回的函数：

<code rust>
fn forever() -> ! {
    loop {
        // 永不退出
    }
}

fn panic_forever() -> ! {
    panic!("直接崩溃"); // panic! 也是发散函数
}
</code>

===== 注释 =====

<code rust>
// 这是单行注释

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

/// 文档注释（生成文档用）
/// 可以包含 Markdown
fn documented_func() {}

//! 模块级别文档注释，写在文件开头
</code>

===== 本章实践 =====

计算圆的面积和周长：

<code rust>
fn circle_area(radius: f64) -> f64 {
    std::f64::consts::PI * radius * radius
}

fn circle_circumference(radius: f64) -> f64 {
    2.0 * std::f64::consts::PI * radius
}

fn main() {
    let r = 5.0;
    println!("半径: {}", r);
    println!("面积: {:.2}", circle_area(r));
    println!("周长: {:.2}", circle_circumference(r));
}
</code>

===== 本章小结 =====

  * 原生类型：整数、浮点、布尔、字符
  * 复合类型：元组和数组
  * 函数用 ''fn'' 声明，用 ''->'' 指定返回类型
  * 最后一个表达式是返回值，''return'' 可省略
  * 语句和表达式的区别