Question

我正在寻找一种允许编译器为模板参数中的给定整数选择最小数据类型的构造。我无法自己找到解决方案的问题是我想如何使用它：

template<typename T, min_type<max_elements_to_store> max_elements_to_store>
class testClass {
private:
    T data[max_elements_to_store];
    min_type<max_elements_to_store> currently_selected_element;
};

宏“min_type”应该为给定的max_elements_to_store（uint8_t，uint16_t，uint32_t，uint64_t）动态选择具有最小位数的类型。我可以通过简单地替换min_type＆lt;＆gt;来修复它具有给定数据类型但这种数据类型通常不是最佳选择。如，

template<typename T, uint64_t max_elements_to_store>
class testClass {
private:
    T data[max_elements_to_store];
    uint64_t currently_selected_element;
};

TestClass<uint8_t, 12> testObject;

这里，数组只能容纳12个元素，而current_selected_element变量浪费了许多位，这些位对于仅访问12个元素根本不是必需的。这似乎只是一个小问题，但是对于访问类中的数据的许多变量来说情况会更糟......

这个问题有解决方案吗？我希望很清楚我在寻找什么。

提前致谢！ INSPIRE

Answer 1

执行此操作的一种方法是使用std::conditional：

#include <type_traits>
#include <cstdint>
#include <limits>

template<std::size_t Count>
using min_type = std::conditional_t<Count <= std::numeric_limits<uint8_t>::max(), uint8_t,
                    std::conditional_t<Count <= std::numeric_limits<uint16_t>::max(), uint16_t,
                        std::conditional_t<Count <= std::numeric_limits<uint32_t>::max(), uint32_t,
                            std::conditional_t<Count <= std::numeric_limits<uint64_t>::max(), uint64_t, void>>>>;

// test: all of the following pass            
static_assert(std::is_same_v<min_type<12>, uint8_t>);
static_assert(std::is_same_v<min_type<1024>, uint16_t>);
static_assert(std::is_same_v<min_type<70000>, uint32_t>);
static_assert(std::is_same_v<min_type<5000000000>, uint64_t>);

template<typename T, std::size_t max_elements_to_store>
class testClass {
private:
    T data[max_elements_to_store];
    min_type<max_elements_to_store> currently_selected_element;
};

TestClass<uint8_t, 12> testObject;

注意：正如@FrançoisAndrieux在评论中指出的那样，由于填充，这将不会保存任何内存（除非您使用特定于编译器的扩展来强制类的打包表示）。

Answer 2

这是一个替代解决方案，使用constexpr函数索引类型选项的元组。

#include <iostream>
#include <tuple>

template <size_t size>
struct min_type {

    constexpr static inline size_t log2(size_t n)  {
        return ( (n<2) ? 0 : 1+log2(n/2));
    }

    constexpr static inline size_t get_index(size_t last,size_t value) {
        return value == 8 ?  last : get_index(last+1,value/2);
    }

    constexpr static inline std::size_t min_type_size(std::size_t v) {
        v--; v |= v >> 1; v |= v >> 2; v |= v >> 4; 
        v |= v >> 8; v |= v >> 16; v++;
        return v < 8 ? 8 : v;
    }

    using type_options = std::tuple<uint8_t,uint16_t,uint32_t,uint64_t>;

    using type = typename std::tuple_element<
        get_index(0,min_type_size(log2(size))),
        type_options>::type;
};

template<typename T, size_t max_elements_to_store>
class testClass {
//private:
  public:
    T data[max_elements_to_store];
    typename min_type<max_elements_to_store>::type currently_selected_element;
};

int main()
{
    min_type<0xff>::type uint_8_value;
    min_type<0xffff>::type uint_16_value;
    min_type<0xffffffff>::type uint_32_value;
    min_type<0xffffffffffffffff>::type uint_64_value;

    static_assert(std::is_same< decltype(uint_8_value),uint8_t>::value,"...");
    static_assert(std::is_same< decltype(uint_16_value),uint16_t>::value,"...");
    static_assert(std::is_same< decltype(uint_32_value),uint32_t>::value,"...");
    static_assert(std::is_same< decltype(uint_64_value),uint64_t>::value,"...");

    testClass<int,12> testcls;

    static_assert(std::is_same< decltype(testcls.currently_selected_element),uint8_t>::value,"...");

    return 0;
}

Demo

具有动态选择的C ++模板类型

2 个答案: