PAYATHON 2026

C语言按数据类型进行输入验证的最佳实践

数据小陈

结论

你给出的 check_data_type 不建议直接使用。按类型分派验证这个方向可以,但实现时要先处理三件事:sscanf 的目标参数类型必须和格式符匹配;要确认整个输入都被消费;范围、符号和浮点特殊值也得检查。_Bool 和 enum 可以加,不过要先定清楚验证规则。如果只是想让它看起来更通用,不必急着加。

原实现的主要问题

  1. 目标类型不匹配,会导致未定义行为。result 是 int,而 %f 需要 float *,%lf 需要 double *,%c 需要 char *,%u 需要 unsigned int *,%ld 需要 long *,%lld 需要 long long *,%x 需要 unsigned int *。把这些格式符对应的 int * 传进去,类型本身就不匹配,行为未定义,结果对错已经无从谈起。

  2. sscanf 返回 1,并不说明整个字符串都合法。比如 12abc 用 %d 会返回 1,1.2x 用 %f 也可能返回 1。尾随字符还得另行检查。

  3. 字符验证的语义不完整。%c 只读一个字符,ab 也可能返回 1。如果这里说的字符是指长度为 1 的输入,需要自己检查 data[1] == 0;如果指的是 Unicode 字符,就不能用单字节 char 简单判断。

  4. 无符号数和十六进制输入要单独处理符号。%u、%x 的目标类型是 unsigned int *,给 int * 不对。strtoul 这类函数还可能接受负号并发生回绕,所以验证无符号数时要显式拒绝负号。

  5. 溢出和范围检查不足。对 int、long、unsigned 等类型,除了看语法是否正确,还要检查值有没有超出目标类型范围。建议用 strtol、strtoul、strtoll、strtoull、strtof、strtod,并结合 errno == ERANGE 和 endptr 做判断。

推荐写法

核心思路是每种类型写一个解析函数,统一入口只负责分派。下面的示例默认允许 strto* 跳过前导空白,但要求除前导空白外整个字符串都被消费。如果你希望完全拒绝空白,得在入口先检查或 trim。

分类型解析函数

#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <ctype.h>

static bool end_ok(const char *s, char *end) {
    return end != s && *end == 0;
}

static const char *skip_ws(const char *s) {
    while (isspace((unsigned char)*s)) s++;
    return s;
}

bool parse_int(const char *s, int *out) {
    if (!s || !*s) return false;
    errno = 0;
    char *end = NULL;
    long v = strtol(s, &end, 10);
    if (errno == ERANGE || !end_ok(s, end)) return false;
    if (v < INT_MIN || v > INT_MAX) return false;
    *out = (int)v;
    return true;
}

bool parse_uint(const char *s, unsigned int *out) {
    if (!s || !*s) return false;
    const char *p = skip_ws(s);
    if (*p == '-') return false;
    errno = 0;
    char *end = NULL;
    unsigned long v = strtoul(s, &end, 10);
    if (errno == ERANGE || !end_ok(s, end) || v > UINT_MAX) return false;
    *out = (unsigned int)v;
    return true;
}

bool parse_hex_uint(const char *s, unsigned int *out) {
    if (!s || !*s) return false;
    const char *p = skip_ws(s);
    if (*p == '-') return false;
    errno = 0;
    char *end = NULL;
    unsigned long v = strtoul(s, &end, 16);
    if (errno == ERANGE || !end_ok(s, end) || v > UINT_MAX) return false;
    *out = (unsigned int)v;
    return true;
}

bool parse_long(const char *s, long *out) {
    if (!s || !*s) return false;
    errno = 0;
    char *end = NULL;
    long v = strtol(s, &end, 10);
    if (errno == ERANGE || !end_ok(s, end)) return false;
    *out = v;
    return true;
}

bool parse_llong(const char *s, long long *out) {
    if (!s || !*s) return false;
    errno = 0;
    char *end = NULL;
    long long v = strtoll(s, &end, 10);
    if (errno == ERANGE || !end_ok(s, end)) return false;
    *out = v;
    return true;
}

bool parse_float(const char *s, float *out) {
    if (!s || !*s) return false;
    errno = 0;
    char *end = NULL;
    float v = strtof(s, &end);
    if (errno == ERANGE || !end_ok(s, end)) return false;
    if (!isfinite(v)) return false; /* policy: reject non-finite */
    *out = v;
    return true;
}

bool parse_double(const char *s, double *out) {
    if (!s || !*s) return false;
    errno = 0;
    char *end = NULL;
    double v = strtod(s, &end);
    if (errno == ERANGE || !end_ok(s, end)) return false;
    if (!isfinite(v)) return false;
    *out = v;
    return true;
}

bool parse_char(const char *s, char *out) {
    if (!s || s[0] == 0 || s[1] != 0) return false;
    *out = s[0];
    return true;
}

统一分派

typedef union {
    int i;
    unsigned int u;
    long l;
    long long ll;
    float f;
    double d;
    char c;
} parsed_value;

bool check_data_type(const char *data, char type_flag, parsed_value *out) {
    if (!data || !out) return false;

    switch (type_flag) {
    case 'i': return parse_int(data, &out->i);
    case 'f': return parse_float(data, &out->f);
    case 'd': return parse_double(data, &out->d);
    case 'c': return parse_char(data, &out->c);
    case 'h': return parse_hex_uint(data, &out->u);
    case 'l': return parse_long(data, &out->l);
    case 'u': return parse_uint(data, &out->u);
    case 'L': return parse_llong(data, &out->ll);
    case 'F': return parse_float(data, &out->f);
    case 'D': return parse_double(data, &out->d);
    default:  return false;
    }
}

如果只需要验证、不保存结果,可以在分派函数里用临时变量,或者给每种类型加一个 validate_* 包装函数,省得调用方误用联合体成员。

_Bool 和 enum 要不要加

可以加,不过它们和普通数值类型不是一回事,别顺手塞进同一组。

  • _Bool:C99 起可用。验证规则要先定:只接受 0/1,还是也接受 true/false?不要用 %d 直接写入 _Bool *,因为 %d 需要 int *。可以先解析成 long,再检查值是否在允许集合内。
  • enum:它不能安全地当作任意整数来用。枚举的底层类型和取值范围由实现定义,而且枚举值不一定连续。若要做通用验证,必须知道具体枚举允许哪些值;否则只能按底层整数类型解析,再检查是否属于合法枚举值集合。
  • void:没有可验证的值,不适合加入。
  • 字符串:长度、编码、空白、业务格式等规则和按数据类型验证不是同一类问题,建议单独做字符串验证。

注意事项

  • 明确空白策略:strto* 会跳过前导空白,但不会自动接受尾随空白;需要统一 trim,或者明确拒绝。
  • 浮点数要决定是否接受 inf、nan 以及本地化小数点;示例用 isfinite 拒绝了非有限值。
  • 十六进制是否允许 0x 前缀、是否允许正负号,应在接口文档里写清楚。无符号场景通常应拒绝负号。
  • char 只适合单字节字符;涉及中文等多字节字符时,改用 mbrtowc、wchar_t 或专门的 Unicode 库。
  • 通用验证函数只能验证类型和范围,不能替代业务合法性校验。

备注:内容仅供参考。