Rust基本数据类型：整型、浮点型与布尔型

在编程的世界里，数据类型就如同建筑的基石，是构建各种复杂程序逻辑的根基。对于 Rust 这门兼具性能与安全的编程语言来说，掌握其基本数据类型更是开启 Rust 编程之旅的关键一步。今天，就让我们一同深入探索 Rust 中的整型、浮点型与布尔型数据类型，通过丰富的实例和详细的阐述，为大家带来一篇干货满满的讲解。

I. 整型数据类型

（一）整型数据类型的分类与特点

在 Rust 中，整型数据类型主要分为有符号整数和无符号整数两大类，它们根据位数不同又有多种具体类型。

• 有符号整数 ：包括 i8、i16、i32、i64、i128 和 isize，这些类型可以表示正数、负数和零。例如，i8 占用 1 个字节（8 位），其取值范围是 -128 到 127；i32 占用 4 个字节（32 位），取值范围是 -2^31 到 2^31 - 1。
• 无符号整数 ：包括 u8、u16、u32、u64、u128 和 usize，这些类型只能表示零和正数。比如，u8 占用 1 个字节，取值范围是 0 到 255；u32 占用 4 个字节，取值范围是 0 到 2^32 - 1。

这些整型数据类型的特点在于它们的位数决定了能表示数值的范围，位数越多，可表示的数值范围越大。同时，Rust 在编译时会根据字面量的值自动推断其整型数据类型，例如，当数字超出某种整型的范围时，需要显式指定类型。

（二）整型数据类型的实例分析

下面，我们来看一个关于整型数据类型的实例：

fn main() {
    let a: i8 = 100;
    let b: i32 = 100000;
    let c: u8 = 255;
    let d: isize = 1024;

    println!("a 的值为：{}，类型为：{}", a, std::any::type_name_of_val(&a));
    println!("b 的值为：{}，类型为：{}", b, std::any::type_name_of_val(&b));
    println!("c 的值为：{}，类型为：{}", c, std::any::type_name_of_val(&c));
    println!("d 的值为：{}，类型为：{}", d, std::any::type_name_of_val(&d));
}

在这个实例中，我们定义了四个不同类型的整型变量 a、b、c 和 d，并分别对其进行了初始化。通过 println! 宏输出每个变量的值和类型，可以看到不同整型数据类型在实际使用中的差异。需要注意的是，isize 和 usize 是与平台相关的类型，它们的位数取决于运行平台是指针的大小，通常在 32 位或 64 位系统中分别为 4 字节或 8 字节。

（三）整型数据类型的溢出问题

在使用整型数据类型时，溢出是一个需要注意的问题。当数值超出其类型所能表示的范围时，就会发生溢出。Rust 在默认情况下，对于有符号整数的溢出会进行 panic（程序崩溃），而对于无符号整数的溢出则会进行模运算处理。

fn main() {
    let max_i8 = i8::MAX;
    let overflow_i8 = max_i8 + 1;

    let max_u8 = u8::MAX;
    let overflow_u8 = max_u8 + 1;

    println!("i8 的最大值为：{}", max_i8);
    println!("i8 溢出后的值为：{}（发生 panic）", overflow_i8);
    println!("u8 的最大值为：{}", max_u8);
    println!("u8 溢出后的值为：{}（进行模运算）", overflow_u8);
}

在上述代码中，i8::MAX 获取了 i8 类型的最大值，在尝试对其加 1 时会发生溢出，导致程序 panic。而 u8::MAX 获取了 u8 类型的最大值，加 1 后会进行模运算，结果变为 0。为了避免溢出问题，在编写代码时需要根据实际情况选择合适的数据类型，并在必要时进行边界检查。

（四）mermaid 总结

II. 浮点型数据类型

（一）浮点型数据类型的分类与特点

Rust 中的浮点型数据类型包括 f32 和 f64，它们遵循 IEEE-754 标准。

• f32 ：单精度浮点数，占用 4 个字节（32 位），大约能提供 6 - 9 位十进制精度。
• f64 ：双精度浮点数，占用 8 个字节（64 位），大约能提供 15 - 17 位十进制精度。

浮点数类型的特点在于它们可以表示小数以及非常大或非常小的数值，但由于其存储方式的限制，浮点数运算可能会存在一定的精度误差，这是在使用浮点数时需要注意的问题。

（二）浮点型数据类型的实例分析

下面是一个关于浮点型数据类型的实例：

fn main() {
    let x: f32 = 3.14;
    let y: f64 = 2.718281828459045;

    println!("x 的值为：{}，类型为：{}", x, std::any::type_name_of_val(&x));
    println!("y 的值为：{}，类型为：{}", y, std::any::type_name_of_val(&y));

    let sum = x + y as f32; // 将 y 转换为 f32 类型后相加
    println!("x + y 的值为：{}", sum);
}

在这个实例中，我们定义了两个浮点型变量 x 和 y，分别使用 f32 和 f64 类型进行初始化。通过 println! 宏输出它们的值和类型，展示了不同浮点型数据类型在实际使用中的区别。同时，我们还进行了浮点数的加法运算，但需要注意类型转换的问题。由于 f32 和 f64 是不同的类型，不能直接进行运算，因此需要将 y 转换为 f32 类型后才能与 x 相加。

（三）浮点型数据类型的特殊值

浮点型数据类型有一些特殊值，如无穷大（INFINITY）、负无穷大（NEG_INFINITY）和非数字（NAN）。

fn main() {
    let inf: f32 = f32::INFINITY;
    let neg_inf: f32 = f32::NEG_INFINITY;
    let nan: f32 = f32::NAN;

    println!("正无穷大：{}", inf);
    println!("负无穷大：{}", neg_inf);
    println!("非数字：{}", nan);
}

在上述代码中，我们使用 f32::INFINITY、f32::NEG_INFINITY 和 f32::NAN 分别获取了正无穷大、负无穷大和非数字的特殊值，并将其输出。这些特殊值在处理某些数学运算或异常情况时可能会出现，例如除以零时会得到无穷大，或者进行非法运算时会得到非数字。

（四）mermaid 总结

III. 布尔型数据类型

（一）布尔型数据类型的定义与特点

布尔型数据类型在 Rust 中用 bool 表示，它只有两个可能的值：true 和 false。布尔型数据类型主要用于表示逻辑判断的结果，在条件语句和循环结构中被广泛使用。

（二）布尔型数据类型的实例分析

下面是一个关于布尔型数据类型的实例：

fn main() {
    let is_rust_fun: bool = true;
    let is_learning: bool = false;

    println!("学习 Rust 是否有趣：{}", is_rust_fun);
    println!("是否正在学习：{}", is_learning);

    let is_greater = 10 > 5;
    println!("10 是否大于 5：{}", is_greater);
}

在这个实例中，我们定义了两个布尔型变量 is_rust_fun 和 is_learning，并分别赋值为 true 和 false。通过 println! 宏输出它们的值，展示了布尔型数据类型的基本使用方法。同时，我们还通过比较运算符 > 判断了 10 是否大于 5，并将结果存储在布尔型变量 is_greater 中，进一步说明了布尔型数据类型在逻辑判断中的应用。

（三）布尔型数据类型在控制流中的应用

布尔型数据类型在条件语句和循环结构中发挥着重要作用。例如：

fn main() {
    let temperature = 25;

    if temperature > 30 {
        println!("天气很热！");
    } else if temperature > 20 {
        println!("天气温暖。");
    } else {
        println!("天气有点凉。");
    }

    let mut count = 0;
    while count < 5 {
        println!("计数：{}", count);
        count += 1;
    }

    for num in 1..=5 {
        println!("数字：{}", num);
    }
}

在上述代码中，我们使用了 if 条件语句根据温度的不同范围输出相应的消息，使用了 while 循环在计数小于 5 时不断输出计数并累加，还使用了 for 循环遍历 1 到 5 的数字并输出。这些控制流结构都依赖于布尔型数据类型来判断条件是否成立，从而决定程序的执行路径。

（四）mermaid 总结

IV. 各数据类型之间的转换

（一）整型与浮点型之间的转换

在 Rust 中，可以使用 as 关键字在整型和浮点型之间进行转换。

fn main() {
    let integer = 10;
    let float_point = integer as f64; // 将整数转换为浮点数

    let float = 3.14;
    let integer_conversion = float as i32; // 将浮点数转换为整数

    println!("整数转换为浮点数：{}", float_point);
    println!("浮点数转换为整数：{}", integer_conversion);
}

在上述代码中，我们将一个整数 integer 转换为 f64 类型的浮点数 float_point，也将一个浮点数 float 转换为 i32 类型的整数 integer_conversion。需要注意的是，这种转换可能会导致精度损失。例如，当将浮点数转换为整数时，小数部分会被截断。

（二）布尔型与其他数据类型之间的转换

布尔型数据类型与其他数据类型之间的转换相对有限，但可以通过一些方式实现特定的转换。

fn main() {
    let boolean = true;
    let boolean_as_integer = boolean as i32; // 将布尔值转换为整数，true 为 1，false 为 0

    let integer = 1;
    let integer_as_boolean = if integer != 0 { true } else { false }; // 将非零整数转换为 true，零转换为 false

    println!("布尔值转换为整数：{}", boolean_as_integer);
    println!("整数转换为布尔值：{}", integer_as_boolean);
}

在上述代码中，我们将布尔值 boolean 转换为整数 boolean_as_integer，其中 true 转换为 1，false 转换为 0。同时，我们将一个非零整数 integer 转换为布尔值 integer_as_boolean，通过判断整数是否等于零来实现转换。需要注意的是，这种转换方式并不是直接的类型转换，而是基于逻辑判断的模拟转换。

（三）mermaid 总结

V. 数据类型的默认值与初始化

（一）变量的默认初始化

在 Rust 中，变量在定义时必须进行初始化，否则会报编译错误。对于基本数据类型，可以使用字面量进行初始化。

fn main() {
    let integer = 42; // i32 类型的整数，默认初始化
    let float = 3.14; // f64 类型的浮点数，默认初始化
    let boolean = true; // 布尔型，默认初始化

    println!("整数：{}", integer);
    println!("浮点数：{}", float);
    println!("布尔值：{}", boolean);
}

在上述代码中，我们定义了三个变量 integer、float 和 boolean，分别用整数字面量、浮点数字面量和布尔字面量进行初始化。Rust 会根据字面量的值自动推断出它们的数据类型。

（二）未初始化变量的错误处理

如果尝试使用未初始化的变量，Rust 编译器会报错。

fn main() {
    let uninitialized_variable; // 定义了一个未初始化的变量
    println!("{}", uninitialized_variable); // 这里会报错：使用了未初始化的变量
}

在上述代码中，定义了一个未初始化的变量 uninitialized_variable，然后试图将其输出。编译器会报错指出使用了未初始化的变量，因为 Rust 要求所有变量在使用前必须明确初始化，以保证程序的内存安全。

（三）mermaid 总结

VI. 数据类型的常量定义

（一）常量的定义与特点

在 Rust 中，可以使用 const 关键字定义常量。常量的特点是其值在编译时就必须确定，并且在程序运行过程中不能改变。

fn main() {
    const MAX_SCORE: i32 = 100;
    const PI: f64 = 3.1415926;

    println!("最高分：{}", MAX_SCORE);
    println!("圆周率：{}", PI);
}

在上述代码中，我们定义了两个常量 MAX_SCORE 和 PI，分别表示最高分和圆周率。常量在定义时必须指定类型，并且其值在编译时必须能够确定。常量的使用有助于提高代码的可读性和可维护性，特别是在需要多次使用同一个固定值的场景下。

（二）常量的作用域与生命周期

常量的作用域从其定义的位置开始，到包含它的模块结束。常量的生命周期贯穿整个程序运行期间，因为它们的值在编译时就已经确定。

fn main() {
    const OUTER_CONST: i32 = 42;

    {
        const INNER_CONST: i32 = 100;
        println!("内部常量：{}", INNER_CONST);
        println!("外部常量：{}", OUTER_CONST); // 可以访问外部常量
    }

    // println!("{}", INNER_CONST); // 这里会报错：INNER_CONST 的作用域已结束
    println!("外部常量：{}", OUTER_CONST);
}

在上述代码中，我们在 main 函数中定义了一个外部常量 OUTER_CONST，并在一个代码块内部定义了一个内部常量 INNER_CONST。在代码块内部可以访问外部常量和内部常量，但代码块外部只能访问外部常量，因为内部常量的作用域仅限于代码块内部。

（三）mermaid 总结

VII. 实例综合应用

（一）综合实例分析

下面是一个综合应用整型、浮点型和布尔型数据类型的实例，模拟一个简单的温度转换程序：

fn main() {
    let temperature_celsius: f32 = 25.5; // 摄氏温度
    let is_freezing = temperature_celsius < 0.0; // 判断是否低于零度

    println!("摄氏温度：{}", temperature_celsius);

    if is_freezing {
        println!("天气很冷，水会结冰！");
    } else {
        println!("天气不是特别冷。");
    }

    let temperature_fahrenheit = celsius_to_fahrenheit(temperature_celsius);
    println!("华氏温度：{}", temperature_fahrenheit);
}

fn celsius_to_fahrenheit(celsius: f32) -> f32 {
    celsius * 9.0 / 5.0 + 32.0 // 摄氏温度转华氏温度的公式
}

在这个实例中，我们定义了一个摄氏温度变量 temperature_celsius，使用浮点型数据类型 f32 进行存储。然后，通过布尔表达式判断温度是否低于零度，并将结果存储在布尔型变量 is_freezing 中。根据布尔值的结果，在条件语句中输出相应的提示信息。最后，调用 celsius_to_fahrenheit 函数将摄氏温度转换为华氏温度，并输出结果。这个实例综合运用了整型（虽然在这个例子中主要使用浮点型，但函数中的整数运算也涉及到整型）、浮点型和布尔型数据类型，展示了它们在实际程序中的相互配合和应用。

（二）代码部署过程

将上述代码保存为 temperature_conversion.rs 文件，然后使用 Rust 编译器进行编译：

rustc temperature_conversion.rs

编译成功后，会生成一个可执行文件（在 Windows 系统上是 temperature_conversion.exe，在 macOS 和 Linux 系统上是一个可执行的二进制文件）。运行该可执行文件：

./temperature_conversion # macOS/Linux
.\temperature_conversion.exe # Windows

程序运行后，会在控制台输出摄氏温度、判断结果以及转换后的华氏温度。

（三）mermaid 总结