Rust 类型转换
- 基本类型转换：在Rust中，使用
as关键字进行显式类型转换，例如将f64浮点数转换为u16整数。 - 字符与整数间的转换：Rust允许将
char类型转换为u8整数，反之亦然。每个字符都有一个Unicode编码，与u8整数相对应。 - 类型转换的限制与错误：Rust类型转换有限制，不是所有数据类型都可以互转。例如，不能直接将浮点数转换为字符。同时，Rust不支持隐式类型转换，防止类型不匹配的错误。
类型转换允许我们将一个数据类型的变量转换为另一种数据类型。在 Rust 中，我们使用 as 关键字来执行类型转换。例如，
// 创建一个浮点型变量
let decimal: f64 = 54.321;
// 将浮点型转换为整型
let integer = decimal as u16;
这里，表达式 decimal as u16; 将 f64 浮点型转换为 u16 整型。
示例：Rust 类型转换
fn main() {
// 将浮点数 f64 值赋给 decimal 变量
let decimal: f32 = 64.31;
// 使用 as 关键字将 decimal 变量转换为 u16 整型
let integer = decimal as u16;
println!("decimal = {}", decimal);
println!("integer = {}", integer);
}
输出：
decimal = 64.31
integer = 64
这里，浮点数值 64.31 的变量 decimal 被转换为 u16 类型的整数值 64，这是通过 Rust 的 as 关键字实现的。
我们使用 as 关键字手动将数据从一种类型转换为另一种类型。这种类型的类型转换也被称为显式类型转换。
类型转换：字符转整数
fn main() {
let character: char = 'A';
// 将 char 类型转换为 u8 整型
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。
类型转换：整数转字符
我们还可以将整数类型转换为字符类型。例如，
fn main() {
// 只有 u8 整型数据类型可以转换为 char
let integer: u8 = 65;
// 使用 as 关键字将整数转换为字符
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;
// 使用 as 关键字将整数转换为字符
let character = integer as char;
println!("integer = {}", integer);
println!("character = {}", character);
}
错误：
error[E0604]: 只有 `u8` 可以被转换为 `char`，而不是 `i32`
--> main.rs:5:19
|
5 | let character = integer as char;
| ^^^^^^^^^^^^^^^ 无效的转换
这里，我们使用了 i32 数据类型，而不是 u8。因此，我们得到了一个错误。
这是因为 Unicode 标量值是小整数，适合在 u8 数据类型的范围内。
Rust 中布尔值转换为整数
fn main() {
let boolean1: bool = false;
let boolean2: bool = true;
// 将布尔类型转换为整数
let integer1 = boolean1 as i32;
let integer2 = boolean2 as i32;
println!("boolean1 = {}", boolean1);
println!("boolean2 = {}", boolean2);
println!("integer1 = {}", integer1);
println!("integer2 = {}", integer2);
}
输出：
boolean1 = false
boolean2 = false
integer1 = 0
integer2 = 1
这里，布尔数据类型 false 和 true 分别被转换为整数 0 和 1。
类型转换的限制
在 Rust 中进行类型转换时存在一些限制。并非所有数据类型都可以相互转换。
例如，我们不能将浮点类型转换为字符。
fn main() {
let decimal: f32 = 65.321;
// 将浮点数转换为 char 数据类型
let character = decimal as char;
println!("decimal = {}", decimal);
println!("character = {}", character);
}
错误：
error[E0604]: 只有 `u8` 可以被转换为 `char`，而不是 `f32`
--> main.rs:5:19
|
5 | let character = decimal as char;
| ^^^^^^^^^^^^^^^ 无效的转换
在这里，我们尝试将 float 类型转换为 char，因此我们得到了一个错误。错误表明 Rust 期望用于转换的是 u8 数据类型，而不是 f32。
常见问题
如何将浮点类型转换为字符？
要将浮点类型转换为字符，你需要先将浮点值 f32 转换为 u8 整型，然后再将其转换为 char。
fn main() {
let decimal: f32 = 65.321;
// 将浮点型转 换为整型数据类型
let integer = decimal as u8;
// 将整型转换为字符数据类型
let character = integer as char;
println!("decimal = {}", decimal);
println!("integer = {}", integer);
println!("character = {}", character);
}
如何在 Rust 中执行隐式类型转换？
在隐式类型转换中，编译器会自动将一种数据类型转换为另一种。这也被称为自动类型转换。
然而，Rust 编程不支持基本/标量类型之间的隐式类型转换。例如，
fn main() {
let integer: u8 = 32.8;
println!("Integer = {}", integer);
}
输出
错误[E0308]: 类型不匹配
--> src/main.rs:2:23
|
2 | let integer: u8 = 32.8;
| -- ^^^^ 期望 `u8`，发现浮点数
| |
| 由于此原因期望
在这里，我们将一个浮点数值赋值给了一个整型变量。由于 Rust 不支持隐式类型转换，32.8 的值不会自动转换为整数值。
因此，我们得到了一个错误。
如何在 Rust 中执行显式类型转换？
正如上文所解释的，我们在 Rust 中使用 as 关键字来执行显式类型转换。
例如，
fn main() {
let pi: f64 = 3.14159265359;
let integer = pi as i32;
println!("pi = {}", pi);
println!("integer = {}", integer);
}
输出：
pi = 3.14159265359
integer = 3