no_std Rust下修复十六进制/十进制字符串转u32函数的方法

云原生阿岚

2026-8-1

问题

我写了一个Rust函数bytes_to_number，能接收"0x152"这类十六进制字符串或"123"这类十进制字符串，返回对应的u32整数。这个函数在std环境下正常工作，但在MCU的no_std环境测试时，因为std和no_std中char类型的功能差异，字符比较和类型转换逻辑失效。比如输入45返回Err("Invalid decimal character")，输入3返回Err("Not a hex or decimal string")，请问怎么修改才能在no_std环境实现同样功能？

原函数代码：

pub fn bytes_to_number(s: &str) -> Result<u32, &'static str> {
    let mut result: u32 = 0;

    // Check if the input is hex or decimal
    let mut chars = s.chars();
    if let Some(c) = chars.next() {
        if c != '0' || chars.next() != Some('x') {
            if '0' <= c && c <= '9' {
                result += c as u32 - '0' as u32;
                for c in chars {
                    let digit= match c {
                        '0'..='9' => c as u32 - '0' as u32,
                        _ => return Err("Invalid decimal character"),
                    };
                    if result >= 429_496_720 {
                        return Err("Integer number too large!")
                    }
                    result = result * 10 + digit;
                    
                }
                return Ok(result)
            }
            return Err("Not a hex or decimal string")
        }
    }
    if chars.clone().count() > 8 {
        return Err("Integer number too large!")
    }
    for c in chars {
        let digit =  match c {
            '0'..='9' => c as u32 - '0' as u32,
            'a'..='f' => c as u32 - 'a' as u32 + 10,
            'A'..='F' => c as u32 - 'A' as u32 + 10,
            _ => return Err("Invalid hex character"),
        };
        result = result * 16 + digit;
    }
    Ok(result)
}

测试异常示例：

输入：45，返回：Err("Invalid decimal character")
输入：3，返回：Err("Not a hex or decimal string")

解决方案

问题核心在于no_std环境下，char的范围比较（如'0' <= c && c <= '9'）和模式匹配中的范围语法依赖std的unicode特性，在精简的no_std环境中行为异常。改用字符的ASCII值进行判断就能彻底解决这个问题，同时优化原逻辑的一些细节：

修改后的函数代码：

pub fn bytes_to_number(s: &str) -> Result<u32, &'static str> {
    let mut result: u32 = 0;
    let mut chars = s.chars();

    if let Some(first_char) = chars.next() {
        // 处理十进制：首字符是数字，且不是0x开头
        if !(first_char == '0' && matches!(chars.next(), Some('x'))) {
            let first_digit = match first_char as u8 {
                b'0'..=b'9' => (first_char as u32) - (b'0' as u32),
                _ => return Err("Not a hex or decimal string"),
            };
            result += first_digit;

            for c in chars {
                let digit = match c as u8 {
                    b'0'..=b'9' => (c as u32) - (b'0' as u32),
                    _ => return Err("Invalid decimal character"),
                };
                // 检查十进制溢出
                if result > u32::MAX / 10 {
                    return Err("Integer number too large!");
                }
                result = result * 10 + digit;
            }
            return Ok(result);
        }
    } else {
        return Err("Empty string");
    }

    // 处理十六进制：已跳过0x前缀
    let hex_chars = chars.collect::<Vec<_>>();
    if hex_chars.len() > 8 {
        return Err("Integer number too large!");
    }

    for c in hex_chars {
        let digit = match c as u8 {
            b'0'..=b'9' => (c as u32) - (b'0' as u32),
            b'a'..=b'f' => (c as u32) - (b'a' as u32) + 10,
            b'A'..=b'F' => (c as u32) - (b'A' as u32) + 10,
            _ => return Err("Invalid hex character"),
        };
        // 检查十六进制溢出
        if result > u32::MAX / 16 {
            return Err("Integer number too large!");
        }
        result = result * 16 + digit;
    }

    Ok(result)
}

关键修改说明：

改用ASCII值判断：将所有char范围比较换成基于c as u8的ASCII字节值判断（如b'0'..=b'9'），no_std环境下ASCII值的范围判断稳定可靠，不依赖unicode特性。
修复迭代器消耗bug：原代码中判断0x前缀时，chars.next()会额外消耗一个字符，导致单个数字输入的迭代器提前耗尽，现在调整判断逻辑避免这个问题。
优化溢出检查：用u32::MAX / 10和u32::MAX /16替代固定数值，逻辑更清晰且跨平台一致。
新增空输入处理：原函数未处理空字符串的情况，现在补充判断避免潜在panic。
简化十六进制长度检查：先将剩余字符收集到Vec中再判断长度，避免no_std下迭代器clone可能带来的问题。

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