【Rust 基础入门】(02) | 数值类型、布尔、字符类型

1. 数值类型

Rust 中的数值类型主要分为两类：整数和浮点数。每种类型都有不同的位数和表示范围，可以根据需求选择合适的类型。

整数类型

• 有符号整数：以 i 开头，表示包含负数、0 和正数。例如：i8、i16、i32、i64、isize。
• 无符号整数：以 u 开头，表示只包含 0 和正数。例如：u8、u16、u32、u64、usize。
• 默认类型：Rust 默认的整数类型是 i32。

浮点数类型

• 单精度浮点数：f32，占用 32 位。
• 双精度浮点数：f64，占用 64 位。
• 默认类型：Rust 默认的浮点数类型是 f64。

示例代码

fn main() {
    // 整数类型
    let a = 42; // 默认是 i32
    let b: u64 = 100; // 显式指定类型

    // 浮点数类型
    let c = 3.14; // 默认是 f64
    let d: f32 = 2.718; // 显式指定类型

    // 不同进制表示
    let decimal = 100_000; // 十进制
    let hex = 0xff; // 十六进制
    let octal = 0o77; // 八进制
    let binary = 0b1111_0000; // 二进制

    println!("a = {}, b = {}, c = {}, d = {}", a, b, c, d);
    println!("decimal = {}, hex = {}, octal = {}, binary = {}", decimal, hex, octal, binary);
}

数值运算

Rust 支持基本的数学运算，但参与运算的变量必须是相同类型。

fn main() {
    // 数学运算示例
    let sum = 1 + 2; // 加法
    let difference = 5.5 - 3.3; // 减法
    let product = 2 * 10; // 乘法
    let quotient = 10.0 / 2.5; // 除法
    let remainder = 10 % 3; // 取模

    println!("sum = {}, difference = {}, product = {}, quotient = {}, remainder = {}", sum, difference, product, quotient, remainder);

    // 变量类型示例
    let x = 55; // 自动推导类型
    let y: i32 = 55; // 显式声明类型
    let z = 55i32; // 类型后缀标注

    // 相同类型，才能运算
    let total = x + y + z;
    println!("{} + {} + {} = {}", x, y, z, total);

    // 数组示例
    let nums = [3.7, 2.89f32, 5.5_f32]; // 其中3.7会自动被推导为f32类型
    println!("{:.2}", nums[0]); // 用 {:.2} 控制小数位为2位
}

整数溢出处理

Rust 提供了多种处理整数溢出的方式：

• wrapping_*：溢出时从最小值重新开始。
• saturating_*：溢出时返回最大值。
• checked_*：溢出时返回 None。
• overflowing_*：返回结果和一个布尔值，表示是否溢出。

fn main() {
    let a: u32 = 4_294_967_295; // u32 最大值
    let b: u32 = 1;

    println!("Wrapping: {}", a.wrapping_add(b)); // 输出 0
    println!("Saturating: {}", a.saturating_add(b)); // 输出 4294967295
    println!("Checked: {:?}", a.checked_add(b)); // 输出 None
    println!("Overflowing: {:?}", a.overflowing_add(b)); // 输出 (0, true)
}

2. 布尔类型

布尔类型只有两个值：true 和 false，占用 1 个字节的内存。

示例代码

fn main() {
    let is_rust_fun = true;
    let is_learning_hard = false;

    if is_rust_fun {
        println!("Rust is fun!");
    }

    if !is_learning_hard {
        println!("Learning Rust is not hard!");
    }
}

短路原则

在逻辑运算中，Rust 会遵循短路原则：

• &&（与运算）：如果第一个表达式为 false，则不会计算第二个表达式。
• ||（或运算）：如果第一个表达式为 true，则不会计算第二个表达式。

fn main() {
    let result = true || expensive_function(); // 不会调用 expensive_function
    println!("Result: {}", result);
}

fn expensive_function() -> bool {
    println!("This function is expensive!");
    true
}

3. 字符类型

Rust 的字符类型 char 占用 4 个字节，可以表示任何 Unicode 字符，包括 ASCII 字符、符号、表情符号等。

示例代码

fn main() {
    let ascii_char = 'A'; // ASCII 字符
    let chinese_char = '中'; // 中文字符
    let emoji = '🦀'; // 表情符号

    println!("ASCII: {}, Chinese: {}, Emoji: {}", ascii_char, chinese_char, emoji);

    // 遍历字符范围
    for c in '你'..='我' {
        print!("{}", c); // 输出从 '你' 到 '我' 之间的所有字符
    }
}

字符与字符串的区别

• 字符：用单引号 ' 表示，固定占用 4 个字节。
• 字符串：用双引号 " 表示，长度可变，使用 UTF-8 编码，一个字符占用 1～4 个字节。