Bitset<0>

template<>
class Bitset<1>
{
 int8_t _a;
}
template<>
class Bitset<2>
{
 int8_t _a;
}

template<size_t _Bits>
    class bitset
    {   // store fixed-length sequence of Boolean elements
public:
    typedef typename _If<_Bits <= 32, _Uint32t, _ULonglong>::type _Ty;

_Ty _Array[_Words + 1]; // the set of bits

//========================================================================
//========================================================================
//========================================================================
 
    /* demangle name ot type */
 
#include <typeinfo>
#include <string>
 
#if defined(__GNUC__) || defined(__MINGW32__) || defined(__MINGW__)
 
    #include <cxxabi.h>
    #include <memory>
    
    std::string demangle(const char* name) {
    
        int status = -1; 
        std::unique_ptr<char, void(*)(void*)> res {
            abi::__cxa_demangle(name, NULL, NULL, &status),
            std::free
        };
        return (status == 0) ? res.get() : name ;
    }
#else
 
    std::string demangle(const char* name) 
        { return name; }
 
#endif
 
template <class T>
std::string view_type(const T& t)
    { return demangle(typeid(t).name()); }
 
template <class T>
std::string view_type()
    { return demangle(typeid(T).name()); }
 
#define dDEMANGLE(type_) \
    view_type<type_>()
 
//========================================================================
//========================================================================
//========================================================================
 
 
 
 
namespace detail
{
    template<size_t N> struct select_type
    {
        enum { is_valid = N>=0  && N<=32 };
        enum { is_00_08 = N>=0  && N<=8  };
        enum { is_09_16 = N>=9  && N<=16 };
        enum { is_17_32 = N>=17 && N<=32 };
        
        static_assert(
            is_valid,
            "\n\n    ERROR: N >=0 && N<=32"
        );
        
        using type = typename std::conditional<is_00_08, uint8_t, 
            typename std::conditional<is_09_16, uint16_t, 
                typename std::conditional<is_17_32, uint32_t, uint64_t>::type
            >::type
        >::type;
    };    
    
}// namespace detail
 
template<size_t N> struct Bitset
{
    using type 
        = typename detail::select_type<N>::type;
};
 
 
#include <iostream>
 
int main()
{
    std::cout << dDEMANGLE(Bitset<3 >::type) << std::endl;
    std::cout << dDEMANGLE(Bitset<9 >::type) << std::endl;
    std::cout << dDEMANGLE(Bitset<31>::type) << std::endl;
}

bitset<UINT_MAX+1> *hash = new bitset<UINT_MAX+1>();
// эквивалентен
bitset<0> *hash = new bitset<0>();

const size_t sz = static_cast<size_t>(UINT_MAX) + 1;
bitset<sz> *hash = new bitset<sz>();