n будет передан в шаблон как параметр, мне нужен тип из него получить

А, понял

сейчас это выглядит так:

template<uint8_t Bits_minus_1_div_8> struct CRC_Type_helper{ typedef uint64_t value_type; }; // default

template<> struct CRC_Type_helper<0> { typedef uint8_t  value_type; }; //for Bits 1..8
template<> struct CRC_Type_helper<1> { typedef uint16_t value_type; }; //for Bits 9..16
template<> struct CRC_Type_helper<2> { typedef uint32_t value_type; }; //for Bits 17..24
template<> struct CRC_Type_helper<3> { typedef uint32_t value_type; }; //for Bits 25..32


#define CRC_TYPE typename CRC_Type_helper< (Bits-1)/8 >::value_type

внутри шаблона просто юзается CRC_TYPE

std::conditional можно попробовать рекурсивно сделать, но я не уверен

template<uint8_t Bits_minus_1_div_8> struct CRC_Type_helper{ typedef uint64_t value_type; }; // default

template<> struct CRC_Type_helper<0> { typedef uint8_t  value_type; }; //for Bits 1..8
template<> struct CRC_Type_helper<1> { typedef uint16_t value_type; }; //for Bits 9..16
template<> struct CRC_Type_helper<2> { typedef uint32_t value_type; }; //for Bits 17..24
template<> struct CRC_Type_helper<3> { typedef uint32_t value_type; }; //for Bits 25..32


#define CRC_TYPE typename CRC_Type_helper< (Bits-1)/8 >::value_type

либо так, либо в constexpr функции-хелпере, но макрос тут явно лишний

почему лишний? он дальше в шаблоне во многих местах. констэкспр это щас можно юзать. код поддерживает 03 плюсы.

щас подвезли С++11 и дальше будет 17. вот я думаю, код можно было бы удалить, если есть стандартные средства.

Макрос на using заменить можно

C++03 - без комментариев, тогда можно и не рассуждать о красоте.
C++17 решение:

#include <cstdint>

template <std::size_t Bits>
auto detect_type() {
    if constexpr (Bits <= 8) {
        return std::uint8_t{};
    }
    else if constexpr (Bits <= 16) {
        return std::uint16_t{};
    }
    else if constexpr (Bits <= 32) {
        return std::uint32_t{};
    }
    else {
        static_assert(Bits <= 64);
        return std::uint64_t{};
    }
}

template <std::size_t Bits> using storage_for = decltype(detect_type<Bits>());

static_assert(std::is_same_v<storage_for<1>, std::uint8_t>);
static_assert(std::is_same_v<storage_for<5>, std::uint8_t>);
static_assert(std::is_same_v<storage_for<12>, std::uint16_t>);
static_assert(std::is_same_v<storage_for<17>, std::uint32_t>);

#include <cstdint>

template <std::size_t Bits>
auto detect_type() {
    if constexpr (Bits <= 8) {
        return std::uint8_t{};
    }
    else if constexpr (Bits <= 16) {
        return std::uint16_t{};
    }
    else if constexpr (Bits <= 32) {
        return std::uint32_t{};
    }
    else {
        static_assert(Bits <= 64);
        return std::uint64_t{};
    }
}

template <std::size_t Bits> using storage_for = decltype(detect_type<Bits>());

ну на 03 кода даже меньше. блин печель...

Мы строчками меряемся? Окей:

template <std::size_t Bits>
auto detect_type() {
    if constexpr (Bits <= 8) { return std::uint8_t{}; }
    else if constexpr (Bits <= 16) { return std::uint16_t{}; }
    else if constexpr (Bits <= 32) { return std::uint32_t{}; }
    else { static_assert(Bits <= 64); return std::uint64_t{}; }
}

Вариант на C++03 не поддерживает 64 бита, для него придётся написать ещё 4 лишних строчки (почти одинаковых).

template <std::size_t Bits>
auto detect_type() {
    if constexpr (Bits <= 8) { return std::uint8_t{}; }
    else if constexpr (Bits <= 16) { return std::uint16_t{}; }
    else if constexpr (Bits <= 32) { return std::uint32_t{}; }
    else { static_assert(Bits <= 64); return std::uint64_t{}; }
}

поддерживает! он по дефолту 64 бита дает. для остальных специализация, и также статик_ассерт за выход из диапазона

template <int N>
using type = std::conditional_t<N <= 8, int8_t, 
             std::conditional_t<N <= 16, int16_t, 
             std::conditional_t<N <= 32, int32_t, 
             std::conditional_t<N <= 64, int64_t, std::nullptr_t>>>>;

Думаю, на 03 это тоже можно написать без проблем. Ну и вместо nullptr_t что-нибудь получше придумать, чтобы ошибка была

типо вместо nullptr_t создать класс с приватным конструктором

Всем привет. Решил разобрать с внутренней структуторой аллокатора. Создал свой контейнер List. Но если я просматриваю элемент через std::for_each или for loop, то после каждой иттерации вызывается деструктор Node ( конкретно после std::cout , хотя я об этом явно не прошу. По стеку вызова после std::cout сразу вызывается деструктор Node. Подскажите пожалуйста, с чем это может быть связано? Это какая - то специфика работы std::allocator<Node<T>> или я тупой и не понимаю чего - то? https://pastebin.com/fEA757GU

Навскидку - лямбда в for_each принимает элемент по значению

Копия

template <int N>
using type = std::conditional_t<N <= 8, int8_t, 
             std::conditional_t<N <= 16, int16_t, 
             std::conditional_t<N <= 32, int32_t, 
             std::conditional_t<N <= 64, int64_t, std::nullptr_t>>>>;

да на 03 как раз все есть и все работает. просто это мой вариант замены бустового црц. который:
1. поддерживают старые плюсы
2. в одном хедере (бустовый тянет малую тележку)
3. поддерживает таблицу для 4х бит. важно для эмбедета
используем для старых проектах на AT91 проце с бареметалл и на ядре 2.6 там гцц 4.2
щас будут обновлятся железки можно будет взять новый компилятор с 17 или даже 20 плюсами.
вот я решил спросить, можно ли это без велосипедов.
ясно что даже на С++11 мы выкидываем статик ассерт на макросах и используем using чтоб статик анализатор не орал. вот подумал, что и этот кусок, можно было заменить на нечто std::traits<bits>::uint_type просто не получилось загуглить

Код, на который вы ответили, работает только с 11 плюсов

даже на 14) conditional_t))