C++类模板如何允许浮点数拓宽输入、禁止窄化？

需求 #

现有一个以浮点类型为模板参数的类模板，要求其DoSomething方法：

• 支持安全浮点拓宽转换（如float→double），自动完成类型转换后执行核心逻辑
• 严格禁止精度丢失的窄化操作（如double→float），触发编译错误

原实现依赖手动特化和if constexpr，存在代码冗余、扩展性差、逻辑分散的问题，需要更简洁的实现方式。

优化方案1：SFINAE + 自定义类型特性（C++17兼容） #

通过自定义类型特性判断安全拓宽关系，结合SFINAE在编译期过滤非法类型，统一处理转换逻辑，避免手动特化。

步骤1：定义安全浮点拓宽特性 #

#include <type_traits>
#include <vector>

// 判断From是否能安全拓宽到To（仅针对标准浮点类型）
template<typename From, typename To>
constexpr bool is_safe_float_widen_v = 
    std::is_floating_point_v<From> && std::is_floating_point_v<To> &&
    (sizeof(From) <= sizeof(To)) && 
    std::is_convertible_v<From, To>;

利用浮点类型的大小关系（float < double < long double）保证拓宽的安全性，同时验证类型可转换性。

步骤2：重构类模板 #

template <typename Real>
class Foo
{
public:
    // 允许同类型或安全拓宽的输入
    template <typename Real2, 
              std::enable_if_t<std::is_same_v<Real, Real2> || is_safe_float_widen_v<Real2, Real>, bool> = true>
    void DoSomething(const std::vector<Real2>& v)
    {
        // 统一处理类型转换：不同类型则转换，同类型直接复用原容器
        const std::vector<Real>& target_v = [&]() -> const std::vector<Real>& {
            if constexpr (!std::is_same_v<Real, Real2>) {
                static std::vector<Real> converted;
                converted.clear();
                converted.reserve(v.size());
                for (auto val : v) {
                    converted.push_back(static_cast<Real>(val));
                }
                return converted;
            } else {
                return reinterpret_cast<const std::vector<Real>&>(v);
            }
        }();

        // ... 在这里编写针对target_v的核心业务逻辑 ...
    }

    // 禁止所有窄化或非法类型输入
    template <typename Real2, 
              std::enable_if_t<!std::is_same_v<Real, Real2> && !is_safe_float_widen_v<Real2, Real>, bool> = true>
    void DoSomething(const std::vector<Real2>&) = delete;
};

效果验证 #

int main()
{
    std::vector<float> v1;
    std::vector<double> v2;
    std::vector<long double> v3;

    Foo<float> b1;
    b1.DoSomething(v1);       // 合法：同类型
    //b1.DoSomething(v2);     // 编译错误：double→float是窄化操作
    //b1.DoSomething(v3);     // 编译错误：long double→float是窄化操作

    Foo<double> b2;
    b2.DoSomething(v1);       // 合法：float→double是安全拓宽
    b2.DoSomething(v2);       // 合法：同类型
    //b2.DoSomething(v3);     // 编译错误：long double→double是窄化操作

    Foo<long double> b3;
    b3.DoSomething(v1);       // 合法：float→long double是安全拓宽
    b3.DoSomething(v2);       // 合法：double→long double是安全拓宽
    b3.DoSomething(v3);       // 合法：同类型
}

优化方案2：C++20 概念(Concepts)简化实现 #

如果使用C++20或更高版本，用概念替代SFINAE，代码可读性和简洁性进一步提升：

步骤1：定义安全拓宽概念 #

#include <concepts>
#include <vector>

template<typename From, typename To>
concept SafeFloatWiden = 
    std::floating_point<From> && std::floating_point<To> &&
    (sizeof(From) <= sizeof(To)) &&
    std::convertible_to<From, To>;

步骤2：重构类模板 #

template <std::floating_point Real>
class Foo
{
public:
    // 处理同类型输入
    void DoSomething(const std::vector<Real>& v)
    {
        process(v);
    }

    // 处理安全拓宽的输入
    template <SafeFloatWiden<Real> Real2>
    void DoSomething(const std::vector<Real2>& v)
    {
        std::vector<Real> converted(v.begin(), v.end());
        process(converted);
    }

    // 禁止所有非法输入
    template <typename Real2>
    void DoSomething(const std::vector<Real2>&) = delete;

private:
    // 提取核心逻辑到私有方法，避免代码重复
    void process(const std::vector<Real>& v)
    {
        // ... 编写核心业务逻辑 ...
    }
};

优化后的优势 #

• 扩展性强：新增浮点类型（如long double）无需修改代码，特性/概念自动识别合法转换
• 逻辑集中：核心业务逻辑仅需编写一次，转换逻辑统一处理
• 错误直观：非法窄化操作会触发= delete的函数匹配，编译器错误信息清晰
• 可读性高：用特性/概念明确表达类型约束，代码意图一目了然

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