如何抽象固定字段数、已知类型的CSV行解析重复逻辑？

先解决你的小疑问：typename T::value为何无效 #

T::value是FieldType的成员变量而非类型，typename仅用于指代嵌套类型。你可以：

1. 继续用decltype(T::value)获取变量的类型；
2. 给FieldType添加嵌套类型别名，让代码更清晰：

template<typename T>
struct FieldType {
    T value;
    using ValueType = T; // 添加类型别名
};

之后就能用T::ValueType代替decltype(T::value)。

核心问题：消除解析逻辑的重复 #

针对固定字段、已知类型的文本解析，我们可以用可变参数模板+折叠表达式封装重复的「拆分-解析-错误检查」流程，同时保证类型安全，无需异常。

方案1：类型安全的批量解析流水线 #

步骤1：封装单字段解析逻辑

先把重复的单字段处理逻辑抽成模板函数，同时用元组存储解析结果（避免std::any的类型不安全问题）：

namespace detail {
// 处理单个字段：拆分字符串、解析、错误检查
template<typename Field, size_t Idx>
bool process_field(std::string_view& rest, auto& result_tuple) {
    auto [field_str, new_rest] = split(rest, ',');
    auto parse_res = parse<Field>(field_str);
    if (parse_res.errorText) {
        return false;
    }
    rest = new_rest;
    std::get<Idx>(result_tuple) = std::move(parse_res.value);
    return true;
}

// 批量处理所有字段的模板函数
template<typename... Fields, size_t... Idx>
auto parse_fields(std::string_view line, std::index_sequence<Idx...>) 
    -> std::variant<std::tuple<Fields...>, std::string> {
    std::string_view rest = line;
    std::tuple<Fields...> parsed;
    std::string error_msg;

    // 用折叠表达式依次处理每个字段
    bool success = true;
    auto check = [&](bool ok) {
        if (!ok && success) {
            // 捕获第一个错误
            auto [field_str, _] = split(rest, ',');
            auto parse_res = parse<Fields...>(field_str);
            error_msg = std::move(parse_res.errorText.value());
            success = false;
        }
    };

    (check(process_field<Fields, Idx>(rest, parsed)), ...);

    if (!success) {
        return error_msg;
    }
    return parsed;
}
} // namespace detail

步骤2：组装最终解析函数

手动列出LineData的字段类型（顺序必须和结构体成员一致），然后批量解析并组装结果：

// 定义LineData的字段类型列表，顺序要严格匹配结构体成员
using LineDataFieldTypes = std::tuple<Name, TextSpecificField, IntSpecificField /*, ... 剩余9个字段 */>;

auto parse(std::string_view line) -> Line {
    using Fields = LineDataFieldTypes;
    auto parse_result = detail::parse_fields<std::tuple_element_t<0, Fields>,
                                            std::tuple_element_t<1, Fields>,
                                            std::tuple_element_t<2, Fields> /*, ... */>(
        line, std::make_index_sequence<std::tuple_size_v<Fields>>{}
    );

    if (std::holds_alternative<std::string>(parse_result)) {
        return InvalidLine{std::string{line}, std::move(std::get<std::string>(parse_result))};
    }

    // 用结构化绑定直接组装LineData
    auto [name, textField, intField /*, ... */] = std::get<Fields>(parse_result);
    return LineData{std::move(name), std::move(textField), std::move(intField) /*, ... */};
}

方案2：模板递归实现（兼容旧标准） #

如果你的编译器不支持C++17的折叠表达式，可以用模板递归替代：

namespace detail {
// 递归终止条件：所有字段处理完成
template<typename... Parsed>
auto finish_parse(std::string_view, std::tuple<Parsed...> parsed) 
    -> std::variant<std::tuple<Parsed...>, std::string> {
    return parsed;
}

// 递归处理每个字段
template<typename NextField, typename... RemainingFields, typename... Parsed>
auto parse_next_field(std::string_view line, std::tuple<Parsed...> parsed) 
    -> std::variant<std::tuple<Parsed..., NextField>, std::string> {
    auto [field_str, rest] = split(line, ',');
    auto parse_res = parse<NextField>(field_str);
    if (parse_res.errorText) {
        return std::move(parse_res.errorText.value());
    }
    return parse_next_field<RemainingFields...>(rest, 
        std::tuple_cat(std::move(parsed), std::make_tuple(std::move(parse_res.value))));
}
} // namespace detail

auto parse(std::string_view line) -> Line {
    auto parse_result = detail::parse_next_field<Name, TextSpecificField, IntSpecificField /*, ... */>(
        line, std::tuple<>{}
    );

    if (std::holds_alternative<std::string>(parse_result)) {
        return InvalidLine{std::string{line}, std::move(std::get<std::string>(parse_result))};
    }

    auto [name, textField, intField /*, ... */] = std::get<std::tuple<Name, TextSpecificField, IntSpecificField /*, ... */>>(parse_result);
    return LineData{std::move(name), std::move(textField), std::move(intField) /*, ... */};
}

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