考虑到可能的类型的小选择，我只需要硬编码条件：

using StorageType = std::conditional_t<Size <=  8, uint8_t,
                    std::conditional_t<Size <= 16, uint16_t,
                    std::conditional_t<Size <= 32, uint32_t, uint_fast32_t>>>;

或者，使用类似于@Caleth的答案的技巧：

using StorageType = std::tuple_element_t<(Size > 8) + (Size > 16) + (Size > 32),
                        std::tuple<uint8_t, uint16_t, uint32_t, uint_fast32_t>>;

带着帮手

namespace detail {

    template <int overload>
    struct StorageType;

    template <>
    struct StorageType<0>{ using type = uint8_t; };

    template <>
    struct StorageType<1>{ using type = uint16_t; };

    template <>
    struct StorageType<2>{ using type = uint32_t; };

    template <>
    struct StorageType<3>{ using type = uint_fast32_t; };
}

然后我们可以对constexpr个布尔值求和

template<size_t Size>
struct BitSet {
    typedef typename detail::StorageType<(Size > 8) + (Size > 16) + (Size > 32)>::type StorageType;
    // an array of that storage type...
};

您可以使用递归模板类，并将非类型模板参数用于位限制，将成员类型别名用于相应的整数类型。
你不需要自己编写这样的模板，Boost已经涵盖了：boost::uint_t<N>::least（或者boost::uint_t<N>::fast，如果你不是在寻找最小但最快的）。
P.S.如果你打算自己实现这个模板，并且你想要最小整数类型（根据标题中的问题），那么你应该使用std::uint_leastN_t而不是uint_fastN_t或uintN_t。前者不一定是最小的类型，后者也不保证在所有系统上都存在。
此外，uint_fast32_t不能保证能够表示超过32位的位，因此对于Size > 32来说，这是一个相当糟糕的选择。我会推荐uint_least64_t代替。

一个冗长的解决方案，少魔术。参考：https://gcc.godbolt.org/z/P2AGZ8

#include<cstdint>

namespace helper { namespace internal {

enum class Size {
    Uint8,
    Uint16,
    Uint32,
    UintFast32,
};

constexpr Size get_size(int s) {
    return (s <= 8 ) ? Size::Uint8:
           (s <= 16) ? Size::Uint16:
           (s <= 32) ? Size::Uint32: Size::UintFast32;
}

template<Size s>
struct FindTypeH;

template<>
struct FindTypeH<Size::Uint8> {
    using Type = std::uint8_t;
};

template<>
struct FindTypeH<Size::Uint16> {
    using Type = std::uint16_t;
};

template<>
struct FindTypeH<Size::Uint32> {
    using Type = std::uint32_t;
};

template<>
struct FindTypeH<Size::UintFast32> {
    using Type = std::uint_fast32_t;
};
}

template<int S>
struct FindType {
    using Type = typename internal::FindTypeH<internal::get_size(S)>::Type;
};
}

template<int S>
struct Myclass {
    using Type = typename helper::FindType<S>::Type;
};

如果你的编译器支持的话，你也可以使用constexpr if--这可能是最容易阅读的一个。基于以下代码的示例：

template<size_t S>
static constexpr auto _findStorageType() {
    static_assert(S > 0, "Invalid storage size");

    if constexpr (S <= sizeof(uint8_t) * CHAR_BIT) return uint8_t{};
    else if constexpr (S <= sizeof(uint16_t) * CHAR_BIT) return uint16_t{};
    else if constexpr (S <= sizeof(uint32_t) * CHAR_BIT) return uint32_t{};
    else if constexpr (S <= sizeof(uint64_t) * CHAR_BIT) return uint64_t{};
    else return __uint128_t{};
}

简单的解决方案：

template<std::size_t MAX_VAL>
using min_unsigned_type = std::tuple_element_t<
    bit_width(MAX_VAL), // See bellow.
    std::tuple<
         std::uint8_t,
         std::uint16_t,
         std::uint32_t,
         std::uint64_t
>>;

这是简单地使用bit_width，即。最小位数，可以适应索引所有类型的std::tuple所需的最大值。
C++20有一个std::bit_width，即constexpr，但如果需要，很容易编写自己的版本。