如何在 u32 和 usize 之间进行惯用转换？

Question

此代码有效并打印“b”：

fn main() {
    let s = "abc";
    let ch = s.chars().nth(1).unwrap();
    println!("{}", ch);
}

另一方面，此代码会导致类型不匹配错误。

fn main() {
    let s = "abc";
    let n: u32 = 1;
    let ch = s.chars().nth(n).unwrap();
    println!("{}", ch);
}

error[E0308]: mismatched types
 --> src/main.rs:5:28
  |
5 |     let ch = s.chars().nth(n).unwrap();
  |                            ^ expected usize, found u32

由于某些外部原因，我必须将 u32 类型用于变量 n。如何将u32 转换为usize 并在nth() 中使用？

Answer 1

as 运算符适用于所有数字类型：

let ch = s.chars().nth(n as usize).unwrap();

Rust 强制你转换整数以确保你知道有符号或溢出。

整数常量可以有类型后缀：

let n = 1u32;

但是，请注意负常数，例如 -1i32 在内部是 - 1i32。

在没有明确类型说明的情况下声明的整数变量显示为{integer}，并且将从方法调用之一正确推断。

Answer 2

您可以做的最谨慎的事情是使用TryFrom 并在值无法放入usize 时恐慌：

use std::convert::TryFrom;

fn main() {
    let s = "abc";
    let n: u32 = 1;
    let n_us = usize::try_from(n).unwrap();
    let ch = s.chars().nth(n_us).unwrap();
    println!("{}", ch);
}

盲目地使用as，当你的代码在usize小于32位的平台上运行时，你的代码会以一种神秘的方式失败。例如，一些微控制器使用 16 位整数作为原生大小：

fn main() {
    let n: u32 = 0x1_FF_FF;
    // Pretend that `usize` is 16-bit
    let n_us: u16 = n as u16;
    
    println!("{}, {}", n, n_us); // 131071, 65535
}

对于u32 以外的更广泛的数字转换类型 usize，请参阅How do I convert between numeric types safely and idiomatically?。

Answer 3

当我们尝试编译您的代码时，我们现在有一个完全不同的答案，将数字 1 替换为 i32 类型的变量：

error[E0308]: mismatched types
 --> src/main.rs:5:28
  |
5 |     let ch = s.chars().nth(n).unwrap();
  |                            ^ expected usize, found i32
help: you can convert an `i32` to `usize` and panic if the converted value wouldn't fit
  |
5 |     let ch = s.chars().nth(n.try_into().unwrap()).unwrap();
  |    

这意味着现在编译器建议您使用 n.try_into().unwrap()，它利用了 TryInto 特性，而 TryInto 又依赖于 TryFrom 并返回 Result<T, T::Error>。这就是为什么我们需要用.unwrap()提取结果

TryInto documentation