如何编写可接受std::optional或算术类型的模板函数并选择正确底层类型

我要实现一个模板函数，既能接收std::optional类型参数，也能接收算术类型参数，核心功能是把字符串转换成对应底层算术类型的值。但当前代码在调用算术类型参数时编译失败，相关代码和错误如下：

原代码 #

#include <optional>
#include <cstdint>
#include <string>
#include <type_traits>

template<typename T, typename F = std::conditional_t<std::is_arithmetic_v<T>,
                                                       T,
                                                       typename T::value_type>>
void convertNumericColumn(std::string &column, T &value)
{
  if (!column.empty())
  {
    try
    {
//      value = boost::lexical_cast<F>(column); // 注释掉以确保代码能尝试编译
    }
    catch(...){}
  };
}

int  main(int, char **)
{
  std::string value = "123";

  std::optional<std::uint64_t> test1;
  std::uint64_t test2;

  convertNumericColumn(value, test1); // 编译通过
  convertNumericColumn(value, test2); // 编译失败
}

编译错误 #

error: 没有匹配的函数调用 'convertNumericColumn(std::string&, uint64_t&)'
error: 'long unsigned int' 不是类、结构体或联合体类型

错误原因 #

问题出在模板的默认参数F上：C++模板在推导默认参数时，会强制解析所有分支的类型，哪怕某个分支的条件不成立。当T是算术类型（比如std::uint64_t）时，虽然std::is_arithmetic_v<T>为true，编译器还是会尝试解析typename T::value_type——而算术类型根本没有value_type这个成员，直接触发编译错误。

修复方案 #

用类型萃取+部分特化的方式，只在T是std::optional时才去提取value_type，算术类型直接使用自身作为底层类型，避免无效的类型解析。修复后的代码如下：

#include <optional>
#include <cstdint>
#include <string>
#include <type_traits>
#include <stdexcept>

// 类型萃取：提取底层算术类型
template<typename T, typename = void>
struct underlying_numeric_type {
    using type = T; // 算术类型直接用自身
};

// 特化处理std::optional类型
template<typename T>
struct underlying_numeric_type<std::optional<T>, std::void_t<typename std::optional<T>::value_type>> {
    using type = typename std::optional<T>::value_type;
};

// 简化类型别名
template<typename T>
using underlying_numeric_type_t = typename underlying_numeric_type<T>::type;

template<typename T>
void convertNumericColumn(std::string &column, T &value)
{
    using F = underlying_numeric_type_t<T>;
    if (!column.empty())
    {
        try
        {
            // 这里可以替换为boost::lexical_cast<F>(column)，或者用标准库转换函数
            auto converted_val = static_cast<F>(std::stoull(column));
            
            // 用if constexpr区分赋值逻辑：算术类型直接赋值，optional则赋值给其内部值
            if constexpr (std::is_arithmetic_v<T>) {
                value = converted_val;
            } else {
                value = converted_val; // std::optional支持直接赋值底层类型
            }
        }
        catch(const std::exception& e) {
            // 可根据需求添加错误处理
        }
        catch(...) {}
    }
}

int main(int, char **)
{
    std::string value = "123";

    std::optional<std::uint64_t> test1;
    std::uint64_t test2;

    convertNumericColumn(value, test1); // 编译通过
    convertNumericColumn(value, test2); // 编译通过
}

关键修复点 #

1. 用underlying_numeric_type模板的部分特化，隔离了std::optional和算术类型的底层类型提取逻辑，编译器只会解析对应分支的类型。
2. 函数内部用if constexpr区分赋值逻辑，确保不同类型的赋值操作都合法。

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