跨平台整数底层类型获取方案的设计问题咨询

我为了在跨平台场景下统一整数类型的边界检查逻辑，实现了下面这个min_underlying模板 trait，用来把C++原生整数类型映射到对应的固定宽度整数类型（比如short int对应int16_t，unsigned long int对应uint32_t等）：

template <typename T> struct min_underlying { using type = T; };
template <> struct min_underlying<short int> { using type = int16_t; };
template <> struct min_underlying<unsigned short int> { using type = uint16_t; };
template <> struct min_underlying<int> { using type = int32_t; };
template <> struct min_underlying<unsigned int> { using type = uint32_t; };
template <> struct min_underlying<long int> { using type = int32_t; };
template <> struct min_underlying<unsigned long int> { using type = uint32_t; };
template <> struct min_underlying<long long int> { using type = int64_t; };
template <> struct min_underlying<unsigned long long int> { using type = uint64_t; };
template <typename T> using min_underlying_t = typename min_underlying<T>::type;

通过这个映射，我可以结合std::numeric_limits来做边界检查：

template <typename T> void check(T n) {
    if(n > (T)std::numeric_limits<min_underlying_t<T>>::max()) 
        error_message("Value exceeds underlying type bounds");
}

但现在遇到了两个棘手的问题：

1. 在64位Unix系统中，std::size_t被定义为unsigned long int，而我的模板把unsigned long int固定映射到了uint32_t。但实际上64位系统里size_t是64位的，这就导致边界检查会错误地把所有超过32位最大值的size_t值判定为非法，可这些值在64位环境下是完全合法的。
2. 这个min_underlying_t不满足幂等性：还是在上述Unix系统中，uint64_t是unsigned long int的别名，所以min_underlying_t<uint64_t>会被解析成min_underlying_t<unsigned long int>，也就是uint32_t，这显然和预期的uint64_t不一致。

想请教一下，有没有更合理的方案来实现这种跨平台的整数类型映射，解决这些问题？

问题根源分析 #

当前方案的核心问题是硬编码了原生类型到固定宽度类型的映射关系，没有考虑不同平台上原生类型的实际宽度。比如你默认unsigned long int始终是32位，但在64位Unix系统中它是64位，这种假设就导致了映射错误和幂等性失效。

根据你的需求，下面提供两种针对性的解决方案：

方案1：基于类型宽度的通用映射（推荐） #

这种方案不依赖具体的类型名，而是通过类型的实际字节宽度和符号属性自动匹配对应的固定宽度类型，完全适配跨平台差异：

#include <cstdint>
#include <type_traits>

template <typename T, size_t Size = sizeof(T), bool IsSigned = std::is_signed_v<T>>
struct min_underlying;

// 16位有符号类型特化
template <typename T>
struct min_underlying<T, 2, true> {
    using type = int16_t;
};

// 16位无符号类型特化
template <typename T>
struct min_underlying<T, 2, false> {
    using type = uint16_t;
};

// 32位有符号类型特化
template <typename T>
struct min_underlying<T, 4, true> {
    using type = int32_t;
};

// 32位无符号类型特化
template <typename T>
struct min_underlying<T, 4, false> {
    using type = uint32_t;
};

// 64位有符号类型特化
template <typename T>
struct min_underlying<T, 8, true> {
    using type = int64_t;
};

// 64位无符号类型特化
template <typename T>
struct min_underlying<T, 8, false> {
    using type = uint64_t;
};

template <typename T>
using min_underlying_t = typename min_underlying<T>::type;

方案优势：

• 完全跨平台：不管原生类型在平台上是32位还是64位，都会自动匹配到对应宽度的固定类型。比如64位Unix下的unsigned long int（8字节）会映射到uint64_t，size_t作为它的别名也会正确映射。
• 天然满足幂等性：固定宽度类型（如uint64_t）的字节宽度和自身一致，所以min_underlying_t<uint64_t>仍然是uint64_t。
• 扩展性好：如果需要支持其他宽度的类型（比如1字节的char），只需添加对应Size参数的特化即可。

方案2：针对原生类型的动态映射 #

如果你更倾向于保留对具体原生类型的控制，但需要适配不同平台的宽度，可以结合std::conditional根据类型的实际宽度来选择映射目标：

#include <cstdint>
#include <type_traits>

template <typename T> struct min_underlying { using type = T; };

// 处理short系列类型
template <> struct min_underlying<short> { using type = int16_t; };
template <> struct min_underlying<unsigned short> { using type = uint16_t; };

// 处理int系列类型
template <> struct min_underlying<int> { using type = int32_t; };
template <> struct min_underlying<unsigned int> { using type = uint32_t; };

// 处理long系列类型：根据当前平台long的宽度动态选择
template <> struct min_underlying<long> {
    using type = std::conditional_t<sizeof(long) == 8, int64_t, int32_t>;
};
template <> struct min_underlying<unsigned long> {
    using type = std::conditional_t<sizeof(unsigned long) == 8, uint64_t, uint32_t>;
};

// 处理long long系列类型
template <> struct min_underlying<long long> { using type = int64_t; };
template <> struct min_underlying<unsigned long long> { using type = uint64_t; };

template <typename T>
using min_underlying_t = typename min_underlying<T>::type;

方案优势：

• 保留类型控制：你可以针对每个原生类型单独定义映射逻辑，同时通过std::conditional适配不同平台的宽度。
• 解决size_t映射问题：64位Unix下unsigned long是8字节，会自动映射到uint64_t，size_t作为其别名也会得到正确的映射结果。
• 满足幂等性：固定宽度类型的映射会回退到默认的type = T（如果没有专门特化的话），或者如果固定宽度类型是某个原生类型的别名，会通过动态选择得到正确结果。

额外优化：更安全的边界检查函数 #

你的check函数中，C风格的类型转换可以替换成更安全的static_cast，同时可以添加有符号类型的下边界检查，配合if constexpr在编译时消除不必要的分支：

#include <limits>

template <typename T> void check(T n) {
    using Underlying = min_underlying_t<T>;
    const auto underlying_max = std::numeric_limits<Underlying>::max();
    const auto underlying_min = std::numeric_limits<Underlying>::min();

    if constexpr (std::is_signed_v<T>) {
        if (n > static_cast<T>(underlying_max) || n < static_cast<T>(underlying_min)) {
            error_message("Value out of underlying type bounds");
        }
    } else {
        if (n > static_cast<T>(underlying_max)) {
            error_message("Value out of underlying type bounds");
        }
    }
}

内容来源于stack exchange