Rust 类型转换

类型转换允许我们将一个数据类型的变量转换为另一个数据类型。在 Rust 中，我们使用 as 关键字执行类型转换。例如，

// create a floating-point variable
let decimal: f64 = 54.321;

// convert floating point type to integer type
let integer = decimal as u16;

在这里，decimal as u16; 表达式将 f64 浮点类型转换为 u16 整型。

示例：Rust 类型转换

fn main() {
    // assign a floating point f64 value to decimal variable
    let decimal: f32 = 64.31;

    // convert decimal variable to u16 integer type using as keyword
    let integer = decimal as u16;

    println!("decimal = {}", decimal);
    println!("integer = {}", integer);
}

输出

decimal = 64.31
integer = 64

在此示例中，变量 decimal 的浮点值为 64.31，通过 as Rust 关键字转换为 u16 类型的整数值 64。

我们使用 as 关键字手动将数据从一种类型转换为另一种类型。这种类型的类型转换也称为显式类型转换。

类型转换：Rust 中的字符到整数转换

fn main() {
    let character: char = 'A';

    // convert char type to u8 integer type
    let integer = char as u8;

    println!("character = {}", character);
    println!("integer = {}", integer);
}

输出

character = A
integer = 65

在 Rust 中，char 数据类型在内部存储为 Unicode 标量值。Unicode 标量值是字符在 Unicode 标准中的数值表示，也称为码点。

字符 A 的 Unicode 值为 65。因此，将字符 A 转换为整数时，输出为 65。

类型转换：Rust 中的整数到字符转换

我们也可以将整数类型转换为字符类型。例如，

fn main() {
    // only u8 integer data type can be converted into char
    let integer: u8 = 65;
  
    // convert integer to char using the as keyword
    let character = integer as char;

    println!("integer = {}" , integer);
    println!("character = {}", character);
}

输出

integer = 65
character = A

在上面的示例中，整数值 65 是字符 A 的 Unicode 码。因此，在类型转换后，输出为字符 A。每个字符都有一个与之关联的 Unicode 码。

整数到字符转换错误

在进行整数和字符之间的类型转换时，我们只允许使用 u8 整数。如果我们使用任何其他整数类型并将其转换为字符，我们会收到错误。例如，

fn main() {
    let integer: i32 = 65;
  
    // convert integer to char using the as keyword
    let character = integer as char;

    println!("integer = {}" , integer);
    println!("character = {}", character);
}

错误

error[E0604]: only `u8` can be cast as `char`, not `i32`
 --> main.rs:5:19
  |
5 |   let character = integer as char;
  |                   ^^^^^^^^^^^^^^^ invalid cast

在这里，我们使用了 i32 数据类型而不是 u8。因此，我们收到错误。

这是因为 Unicode 标量值是较小的整数，适合 u8 数据类型的范围。

类型转换：Rust 中的布尔值到整数转换

fn main() {
    let boolean1: bool = false;
    let boolean2: bool = true;
  
    // convert boolean type to integer
    let integer1 = boolean1 as i32;
    let integer2 = boolean2 as i32;

    println!("boolean1 = {}", boolean1);
    println!("boolean1 = {}", boolean2);
    println!("integer1 = {}", integer1);
    println!("integer2 = {}", integer2);
}

输出

boolean1 = false
boolean1 = false
integer1 = 0
integer2 = 1

在这里，布尔数据类型 false 和 true 分别转换为整数 0 和 1。

类型转换的限制

在 Rust 中执行类型转换存在限制。并非所有数据类型都可以相互转换。

例如，我们不能将浮点类型转换为字符。

fn main() {
    let decimal: f32 = 65.321;
  
    // convert float to char data type
    let character = decimal as char;

    println!("decimal = {}", decimal);
    println!("character = {}", character);
}

错误

error[E0604]: only `u8` can be cast as `char`, not `f32`
 --> main.rs:5:19
  |
5 |   let character = decimal as char;
  |                   ^^^^^^^^^^^^^^^ invalid cast

在这里，我们尝试将 float 类型转换为 char，因此我们收到错误。错误表明 Rust 期望 u8 数据类型进行转换，而不是 f32。

fn main() {
    let decimal: f32 = 65.321;

    // convert float to integer data type
    let integer = decimal as u8;

    // convert integer to char data type
    let character = integer as char;

    println!("decimal = {}", decimal);
    println!("integer = {}", integer);
    println!("character = {}", character);
}

fn main() {
    let integer: u8 = 32.8;
    
    println!("Integer = {}", integer);
}

error[E0308]: mismatched types
 --> src/main.rs:2:23
  |
2 |     let integer: u8 = 32.8;
  |                  --   ^^^^ expected `u8`, found floating-point number
  |                  |
  |                  expected due to this

fn main() {
    let pi: f64 = 3.14159265359;

    let integer = pi as i32;

    println!("pi = {}", pi);
    println!("integer = {}", integer);
}

pi = 3.14159265359
integer = 3