C++依赖于模板类型的数组类型

Question

我有一个具有完整模板参数N的类。

template<unsigned int N> 
class test { 
} 

现在我想有一个std::vector与整型是尽可能小以保持N位。

例如

class test<8> { 
    std::vector<uint8_t> data; 
} 

class test<9> { 
    std::vector<uint16_t> data; 
} 

class test<10> { 
    std::vector<uint16_t> data; 
} 
... 

有没有更好的方式来为N=1到N=64做到这一点？

Answer 1

如何使用条件？

#include <vector> 
#include <cstdint> 
#include <iostream> 
#include <type_traits> 

template <std::size_t N> 
struct foo 
{ 
    static_assert(N < 65U, "foo 64 limit"); 

    using vType = typename std::conditional< 
     (N < 9U), std::uint8_t, 
     typename std::conditional< (N < 17U), std::uint16_t, 
      typename std::conditional< (N < 33U), std::uint32_t, std::uint64_t 
    >::type>::type>::type; 

    std::vector<vType> data; 
}; 

int main() 
{ 
    static_assert(1U == sizeof(foo<1>::vType), "!"); 
    static_assert(1U == sizeof(foo<8>::vType), "!"); 
    static_assert(2U == sizeof(foo<9>::vType), "!"); 
    static_assert(2U == sizeof(foo<16>::vType), "!"); 
    static_assert(4U == sizeof(foo<17>::vType), "!"); 
    static_assert(4U == sizeof(foo<32>::vType), "!"); 
    static_assert(8U == sizeof(foo<33>::vType), "!"); 
    static_assert(8U == sizeof(foo<64>::vType), "!"); 

    // foo<65> f65; compilation error 
} 

或者，在一个更优雅的方式（恕我直言），你可以定义一个类型的特征（selectTypeByDim，在下面的例子），在列表中选择第一个有用的类型基于

#include <tuple> 
#include <vector> 
#include <cstdint> 
#include <climits> 
#include <type_traits> 

template <std::size_t N, typename T, 
    bool = (N <= sizeof(typename std::tuple_element<0U, T>::type)*CHAR_BIT)> 
struct stbdH; 

template <std::size_t N, typename T0, typename ... Ts> 
struct stbdH<N, std::tuple<T0, Ts...>, true> 
{ using type = T0; }; 

template <std::size_t N, typename T0, typename ... Ts> 
struct stbdH<N, std::tuple<T0, Ts...>, false> 
{ using type = typename stbdH<N, std::tuple<Ts...>>::type; }; 

template <std::size_t N, typename ... Ts> 
struct selectTypeByDim : stbdH<N, std::tuple<Ts...>> 
{ }; 

template <std::size_t N> 
struct foo 
{ 
    static_assert(N < 65U, "foo 64 limit"); 

    using vType = typename selectTypeByDim<N, 
     std::uint8_t, std::uint16_t, std::uint32_t, std::uint64_t>::type; 

    std::vector<vType> data; 
}; 

int main() 
{ 
    static_assert(1U == sizeof(foo<1U>::vType), "!"); 
    static_assert(1U == sizeof(foo<CHAR_BIT>::vType), "!"); 
    static_assert(2U == sizeof(foo<CHAR_BIT+1U>::vType), "!"); 
    static_assert(2U == sizeof(foo<(CHAR_BIT<<1)>::vType), "!"); 
    static_assert(4U == sizeof(foo<(CHAR_BIT<<1)+1U>::vType), "!"); 
    static_assert(4U == sizeof(foo<(CHAR_BIT<<2)>::vType), "!"); 
    static_assert(8U == sizeof(foo<(CHAR_BIT<<2)+1U>::vType), "!"); 
    static_assert(8U == sizeof(foo<(CHAR_BIT<<3)>::vType), "!"); 

    //foo<(CHAR_BIT<<3)+1U> f65; compilation error 
} 

Answer 2

对你的问题的评论，你并不需要一个内置的类型。任何可复制的可移动对象都可以放入矢量中。

如果你想要的数据做的是排序的话，我会建议，要么std::bitset<2*N>或std::array<std::byte, (2*N+7)/8>（或者，如果你一个奇怪的系统上运行std::array<std::byte, (2*N+CHAR_BIT-1)/CHAR_BIT>）定制Compare排序。如果您有任何其他用途（您可能会这样做），我会推荐一个自定义类，并将其中的一个用作其基础存储;这可以让您添加更多功能，如获取特定的基础。

在大多数系统上，如果N是32或64（取决于实现）的倍数，则std::bitset将不会有任何开销，但不能保证。一般来说，字节数组的开销不会超过C++所要求的开销。如果有必要，这两种扩展都可以扩展到64位以上，并且字节数组的空间开销最小，比使用整型更少，因为它不会强制大小为2的幂。在其中任何一个上面添加自定义类都不会产生任何开销。

（如果使用的是C++ 14或以下，您可以使用char或uint8_t，而不是byte;一个byte是更接近你想要什么，但只在C++ 17可如果你使用C +现在+14，但可能会切换，我建议将using byte = uint8_t放在代码的某个地方，然后在升级时将其切换出来）