利用模板元编程消除C++有符号-无符号比较警告

问题背景 #

为实现类似Python的三元比较（a <= b <= c）功能，编写了一组区间判断辅助函数：

// 判断test是否在[low, high]区间内
template<typename Low, typename Val, typename High>
bool between(Low const& low, Val const& test, High const& high);

// 判断test是否在(low, high)区间内
template<typename Low, typename Val, typename High>
bool within(Low const& low, Val const& test, High const& high);

// 判断test是否在[low, high)区间内
template<typename Low, typename Val, typename High>
bool contained(Low const& low, Val const& test, High const& high);

这些函数功能正常，但开启编译器警告后出现有符号-无符号比较警告。为避免晦涩的手动类型转换，尝试用模板元编程实现自动转换的cmp函数，但遇到编译错误。

初始尝试与问题 #

最初的cmp函数通过模板条件转换类型，能处理整数但无法比较std::string：

template<typename Lhs, typename Rhs>
auto cmp(Lhs const& lhs, Rhs const& rhs) -> std::strong_ordering
{
    using Lhs_t  = std::conditional_t<(std::is_signed<Lhs>() == std::is_signed<Rhs>()),
                                     decltype(lhs),
                                     std::make_signed_t<Lhs>>;
    using Rhs_t  = std::conditional_t<(std::is_signed<Lhs>() == std::is_signed<Rhs>()),
                                     decltype(rhs),
                                     std::make_signed_t<Rhs>>;
    auto&& lhs_v = static_cast<Lhs_t>(lhs);
    auto&& rhs_v = static_cast<Rhs_t>(rhs);

    return lhs_v <=> rhs_v;
}

SFINAE重载尝试与编译错误 #

为区分整数和非整数类型，尝试用std::enable_if实现重载，但出现编译错误：

template<typename Lhs, typename Rhs>
typename std::enable_if_t<std::conjunction_v<std::is_integral_v<Lhs>, std::is_integral_v<Rhs>>, std::strong_ordering>
cmp(Lhs const& lhs, Rhs const& rhs)
{
    using Lhs_t  = std::conditional_t<(std::is_signed<Lhs>() == std::is_signed<Rhs>()),
                                     decltype(lhs),
                                     std::make_signed_t<Lhs>>;
    using Rhs_t  = std::conditional_t<(std::is_signed<Lhs>() == std::is_signed<Rhs>()),
                                     decltype(rhs),
                                     std::make_signed_t<Rhs>>;
    auto&& lhs_v = static_cast<Lhs_t>(lhs);
    auto&& rhs_v = static_cast<Rhs_t>(rhs);

    return lhs_v <=> rhs_v;
}

// 非整数类型比较（如字符串）
template<typename Lhs, typename Rhs>
typename std::enable_if_t<std::negation_v<std::conjunction_v<std::is_integral_v<Lhs>, std::is_integral_v<Rhs>>>,
                          std::strong_ordering>
cmp(Lhs const& lhs, Rhs const& rhs)
{
    return lhs <=> rhs;
}

编译错误信息：

/usr/src/project/util/unit/../bool.hh:20:5: note:   template argument deduction/substitution failed:
/usr/src/project/util/unit/../bool.hh: In substitution of 'template<class Lhs, class Rhs> std::enable_if_t<conjunction_v<is_integral_v<Lhs>, is_integral_v<Rhs> >, std::strong_ordering> {anonymous}::cmp(const Lhs&, const Rhs&) [with Lhs = unsigned int; Rhs = int]':
/usr/src/project/util/unit/../bool.hh:53:28:   required from 'bool is_le(const Lhs&, const Rhs&) [with Lhs = unsigned int; Rhs = int]':
/usr/src/project/util/unit/bool_unittest.cpp:21:5:   required from here
/usr/src/project/util/unit/../bool.hh:19:36: error: type/value mismatch at argument 1 in template parameter list for 'template<class ... _Bn> constexpr const bool std::conjunction_v<_Bn ...>'
   19 |     typename std::enable_if_t<std::conjunction_v<std::is_integral_v<Lhs>, std::is_integral_v<Rhs>>, std::strong_ordering>
      |                               ~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/src/project/util/unit/../bool.hh:19:36: note:   expected a type, got 'std::is_integral_v<unsigned int>'
/usr/src/project/util/unit/../bool.hh:19:36: error: type/value mismatch at argument 1 in template parameter list for 'template<class ... _Bn> constexpr const bool std::conjunction_v<_Bn ...>'
/usr/src/project/util/unit/../bool.hh:19:36: note:   expected a type, got 'std::is_integral_v<int>'

修复方案 #

错误原因 #

std::conjunction_v的模板参数必须是类型（如std::is_integral<Lhs>），但代码中错误传入了std::is_integral_v<Lhs>——这是一个bool值，导致类型不匹配。

修复后的代码 #

#include <type_traits>
#include <compare>
#include <string>

// 整数类型专用比较：自动处理有符号-无符号转换，避免警告
template<typename Lhs, typename Rhs>
std::enable_if_t<std::is_integral_v<Lhs> && std::is_integral_v<Rhs>, std::strong_ordering>
cmp(const Lhs& lhs, const Rhs& rhs)
{
    // 先获取两个整数的共同类型，再转换为该类型的有符号版本，避免溢出和比较警告
    using CommonType = std::common_type_t<Lhs, Rhs>;
    using SignedCommonType = std::make_signed_t<CommonType>;

    return static_cast<SignedCommonType>(lhs) <=> static_cast<SignedCommonType>(rhs);
}

// 非整数类型比较：直接使用原生三路比较
template<typename Lhs, typename Rhs>
std::enable_if_t<!(std::is_integral_v<Lhs> && std::is_integral_v<Rhs>), decltype(auto)>
cmp(const Lhs& lhs, const Rhs& rhs)
{
    return lhs <=> rhs;
}

// 区间判断函数实现示例
template<typename Low, typename Val, typename High>
bool between(const Low& low, const Val& test, const High& high)
{
    return cmp(low, test) <= 0 && cmp(test, high) <= 0;
}

template<typename Low, typename Val, typename High>
bool within(const Low& low, const Val& test, const High& high)
{
    return cmp(low, test) < 0 && cmp(test, high) < 0;
}

template<typename Low, typename Val, typename High>
bool contained(const Low& low, const Val& test, const High& high)
{
    return cmp(low, test) <= 0 && cmp(test, high) < 0;
}

关键修复点 #

1. 修正SFINAE条件：用std::is_integral_v<Lhs> && std::is_integral_v<Rhs>直接判断是否为整数类型，替代错误的std::conjunction_v用法，逻辑更清晰且避免类型不匹配。
2. 优化类型转换逻辑：改用std::common_type_t获取两个整数的共同类型，再转换为该类型的有符号版本，确保转换安全，同时彻底消除有符号-无符号比较警告。
3. 适配非整数返回类型：非整数重载使用decltype(auto)推导返回类型，兼容不同类型的三路比较结果（如std::string返回std::strong_ordering，部分类型可能返回std::weak_ordering）。

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