#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;
}
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