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