如何在Rust中使用TryFrom trait将usize转换为u32？

我需要在Rust中将usize类型变量转换为u32类型变量，已知usize的值可能超过2^32，此时转换应失败。我尝试使用TryFrom trait实现转换，但编译失败了。

测试代码（Nightly Rust，可通过Playground运行）：

#![feature(try_from)]
use std::convert::TryFrom;

fn main() {
    let a: usize = 0x100;
    let res = u32::try_from(a);
    println!("res = {:?}", res);
}

报错信息：

error[E0277]: the trait bound `u32: std::convert::From<usize>` is not satisfied
 --> src/main.rs:6:15
  |
6 |     let res = u32::try_from(a);
  |               ^^^^^^^^^^^^^ the trait `std::convert::From<usize>` is not implemented for `u32`
  |
= help: the following implementations were found:
          <u32 as std::convert::From<std::net::Ipv4Addr>>
          <u32 as std::convert::From<u8>>
          <u32 as std::convert::From<char>>
          <u32 as std::convert::From<u16>>
= note: required because of the requirements on the impl of `std::convert::TryFrom<usize>` for `u32`

从报错可知，u32实现TryFrom<usize>依赖于u32实现From<usize>，这令我困惑。请问是否有其他方式用TryFrom完成该转换？若没有，Rust中是否有符合习惯的替代转换方法？我知道可以用as关键字，但它无法告知转换是否失败；也可以自行编写转换函数，但作为基础类型，Rust应该有惯用方案。

这个问题的根源在于你使用的是旧版TryFrom trait的实现逻辑——早期Nightly版本中，TryFrom的默认实现确实依赖于From trait，但由于usize的大小是平台相关的（32位系统上为32位，64位系统上为64位），标准库无法无条件为u32实现From<usize>（64位系统下usize比u32大，直接转换会丢失数据），所以也就没有对应的默认TryFrom<usize>实现。

不过现在有更简洁且符合Rust惯用风格的解决方案：

方案1：使用稳定版Rust的标准TryFrom/TryInto #

从Rust 1.34版本开始，标准库已经为所有整数类型之间的转换实现了TryFrom和TryInto，不需要启用任何Nightly feature。这些实现会自动检查值是否在目标类型的范围内，超出则返回Err：

use std::convert::TryFrom;

fn main() {
    // 正常转换：值在u32范围内
    let a: usize = 0x100;
    let res = u32::try_from(a);
    println!("res = {:?}", res); // 输出: res = Ok(256)

    // 超出范围的转换：返回错误
    let b: usize = u32::MAX as usize + 1;
    let res_b = u32::try_from(b);
    println!("res_b = {:?}", res_b); // 输出: res_b = Err(TryFromIntError(()))
}

你也可以使用TryInto（TryFrom的反向trait），写法更简洁：

use std::convert::TryInto;

fn main() {
    let a: usize = 0x100;
    let res: Result<u32, _> = a.try_into();
    println!("res = {:?}", res);
}

方案2：手动实现范围检查（兼容旧版本） #

如果你必须使用较旧的Rust版本，也可以手动实现安全转换，这也是Rust社区认可的惯用方式之一：

use std::num::TryFromIntError;

fn usize_to_u32(n: usize) -> Result<u32, TryFromIntError> {
    if n > u32::MAX as usize {
        Err(TryFromIntError(()))
    } else {
        Ok(n as u32)
    }
}

fn main() {
    let a: usize = 0x100;
    println!("res = {:?}", usize_to_u32(a)); // Ok(256)

    let b: usize = u32::MAX as usize + 1;
    println!("res_b = {:?}", usize_to_u32(b)); // Err(TryFromIntError(()))
}

这种方式的好处是完全可控，你甚至可以自定义错误类型，但显然使用标准库提供的TryFrom/TryInto是更优的选择，因为它已经经过了充分的测试，且符合Rust的设计哲学。

内容的提问来源于stack exchange，提问作者real