C语言中如何安全将char*转换为unsigned int类型

我编写了一个简易函数用于在C语言中实现char*到unsigned int的类型转换，请问该实现是否完全安全？如果存在安全隐患，还有哪些其他实现方式？

补充说明：我重写了该函数，新增了更有效的错误校验逻辑，代码如下：

#define UNLESS(x) if (!(x))

int char_to_uint(const char *str, unsigned int* res)
{    
    /* return 0 if str is NULL */
    if (!str){
        return 0;
    }

    char *buff_temp;
    long long_str;

    /* we set up errno to 0 before */
    errno = 0;

    long_str = strtol(str, &buff_temp, 10); 

    /* some error and boundaries checks */
    if (buff_temp == str || *buff_temp != '\0' || long_str < 0){
        return 0; 
    }

    /* errno != 0 = an error occured */
    if ((long_str == 0 && errno != 0) || errno == ERANGE){
        return 0;
    }

    /* if UINT_MAX < ULONG_MAX so we check for overflow */
    UNLESS(UINT_MAX == ULONG_MAX){
        if (long_str > UINT_MAX) {
            return 0;
        } else {
            /* 0xFFFFFFFF : real UINT_MAX */
            if(long_str > 0xFFFFFFFF){ 
                return 0;
            } 
        }  
    }

    /* after that, the cast is safe */
    *res = (unsigned int)long_str;

    return 1;
}

现有实现的安全隐患 #

这个实现并不完全安全，存在以下明确问题：

• 未校验输出指针res是否为NULL：如果调用时传入的res是空指针，最后执行*res = (unsigned int)long_str会直接触发空指针解引用，导致程序崩溃。
• 硬编码0xFFFFFFFF作为UINT_MAX的判断逻辑冗余且存在兼容性风险：标准库<limits.h>定义的UINT_MAX是适配当前平台的正确值，硬编码32位无符号整数最大值的逻辑，在非32位int的平台（比如16位int的嵌入式环境、64位int的特殊架构）会直接导致溢出校验失效；且在你判断过long_str > UINT_MAX直接返回的前提下，后面的硬编码判断永远不会触发，属于无效代码。
• 存在合法值误判漏洞：strtol返回的是有符号long类型，当long和unsigned int宽度相同时（比如32位系统下两者都是32位），LONG_MAX（2^{31-1）小于`UINT_MAX`（2}32-1），此时如果输入字符串对应值在LONG_MAX+1到UINT_MAX区间，strtol会返回LONG_MAX并设置errno=ERANGE，你的代码会直接判定为错误，但实际上这个值属于合法的unsigned int取值。
• 自定义宏UNLESS存在维护风险：非通用的语法宏在多人协作场景下容易造成误读，若和其他代码块的花括号匹配出错，还可能引发悬空else类的逻辑bug。
• 存在隐式声明风险：代码用到了strtol、errnoerrno、ERANGE、UINT_MAX/ULONG_MAX，如果没有提前包含<stdlib.h>、<errno.h>、<limits.h>头文件，不同编译器下可能出现类型不匹配、返回值截断的问题。
• 边界语义未明确定义：strtol默认会跳过字符串开头的空白字符（空格、制表符、换行符等），如果业务逻辑要求传入字符串必须是纯数字、不允许带前导空白，当前实现不会拦截这类输入，属于逻辑边界模糊的隐患。

更可靠的实现方式 #

方案1：基于标准库函数的精简安全实现 #

保留原有标准库调用的思路，修复所有漏洞，逻辑更简洁：

#include <stdlib.h>
#include <errno.h>
#include <limits.h>

int char_to_uint(const char *str, unsigned int* res)
{
    // 校验所有入参非空
    if (str == NULL || res == NULL) {
        return 0;
    }

    char *endptr;
    errno = 0;
    // 改用无符号长整型转换函数，从根源避免有符号类型上限不足导致的合法值误判
    unsigned long val = strtoul(str, &endptr, 10);

    // 校验转换有效性：无可转换字符、末尾存在非数字字符、值溢出
    if (endptr == str || *endptr != '\0' || errno == ERANGE) {
        return 0;
    }

    // 校验值不超过当前平台unsigned int上限
    if (val > UINT_MAX) {
        return 0;
    }

    *res = (unsigned int)val;
    return 1;
}

方案2：逐字符手动实现（无标准库转换依赖，适合裸机嵌入式场景） #

如果是资源受限无法调用标准库转换函数的场景，可以逐字符解析，逻辑完全可控：

#include <ctype.h>
#include <limits.h>

int char_to_uint(const char *str, unsigned int* res)
{
    if (str == NULL || res == NULL) {
        return 0;
    }

    // 跳过前导空白，不需要该特性可直接删除此段
    while (isspace((unsigned char)*str)) {
        str++;
    }

    // 拦截负号开头的输入
    if (*str == '-') {
        return 0;
    }
    // 允许前导正号，不需要该特性可直接删除此段
    if (*str == '+') {
        str++;
    }

    // 开头必须为数字
    if (!isdigit((unsigned char)*str)) {
        return 0;
    }

    unsigned int val = 0;
    while (isdigit((unsigned char)*str)) {
        unsigned int digit = *str - '0';
        // 提前计算溢出风险，避免中间值触发未定义行为
        if (val > UINT_MAX / 10 || (val == UINT_MAX / 10 && digit > UINT_MAX % 10)) {
            return 0;
        }
        val = val * 10 + digit;
        str++;
    }

    // 不允许末尾存在非数字字符
    if (*str != '\0') {
        return 0;
    }

    *res = val;
    return 1;
}

该实现每一步计算前都做溢出判断，不会出现中间结果溢出的未定义行为，可根据业务需求灵活裁剪是否支持前导空白、前导正号的特性。

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