Нет, это тип, который на твоей системе вмещает любое количество элементов в памяти

не совсем то, но что-то похожее, спасибо
оно для std::common_type_t<int, unsigned> выводит unsigned

Если у тебя 32-битная система, то char[5000000000] сделать не получится в любом случае

И правда.. Скорее всего, придётся самому писать, т.к. есть много граничных случаев

а, ну справедливо, действительно

ну если чуть более формально, то мне бы вывести тип C, для которого выполняетс

я:

std::numeric_limits<C>::max() >= std::numeric_limits<A>::max() &&
std::numeric_limits<C>::max() >= std::numeric_limits<B>::max() &&
std::numeric_limits<C>::min() <= std::numeric_limits<A>::min() &&
std::numeric_limits<C>::min() <= std::numeric_limits<B>::min() 

Где A, B - типы переданных а

ргументов

я просто не очень хорошо понимаю, каким образом все целочисленные типы перебрать. Просто руками вбить int, unsigned, long .... или что-то умнее есть?

никаким не перебрать

перебирать это в раст

понял, пошел в раст kekWait

Тебя фактически интересует sizeof и sign. Берешь от исходных типов sizeof и sign, комбинируешь каким-то образом, получаешь результат и по результату уже нужно будет найти тип (пара специализаций шаблонов)

ага, идею вроде понял, благодарю

ему нужно уметь переходить к более широкому signed

втупую это делается просто бросанием наибольшего sizeof в шаблон, который специализирован для всех немногочисленных случаев и возвращает тип больший по размеру

ну кроме как явно задать порядок ваще хз

не знаю какой там диапазон возможных сценариев, вроде примерно раз два и обчелся

Примерно так:

template <std::size_t Size, bool IsSigned>
struct helper;

template <1, true> struct helper { using type = std::int8_t; };
template <1, false> struct helper { using type = std::uint8_t; };
// ...

constexpr auto size1 = sizeof(L);
constexpr auto sign1 = std::is_signed_v<L>;
constexpr auto size2 = sizeof(R);
constexpr auto sign2 = std::is_signed_v<R>;

constexpr auto size = MAGIC(...);
constexpr auto sign = MAGIC(...);

using Result = typename helper<size, sign>::type;

я бы прошелся по int_least8_t int_least16_t int_least32_t int_least64_t наверн

и intmax_t

Звучит разумно

по идее, чтобы много специализаций не делать, можно

template <N, true> struct helper { using type = std::conditional_t<...>; } // и рекурсивно через conditional'ы определить тип
template <N, false> struct helper { using type = std::conditional_t<...>; }

template <int N>
using type = std::conditional_t<N <= 1, int8_t, 
             std::conditional_t<N <= 2, int16_t, 
             std::conditional_t<N <= 4, int32_t, 
             std::conditional_t<N <= 8, int64_t, std::nullptr_t>>>>; //типо такого, только через int_least, как выше предложили