Найдите макс. целочисленный размер, который тип с плавающей точкой может обработать без потери точности
Дважды имеет диапазон больше, чем 64-разрядное целое число, но его точность является меньшим количеством взносов к его представлению (так как дважды является 64-разрядным также, он не может соответствовать более фактическим значениям). Так, при представлении больших целых чисел Вы начинаете терять точность в целой части.
#include <boost/cstdint.hpp>
#include <limits>
template<typename T, typename TFloat>
void
maxint_to_double()
{
T i = std::numeric_limits<T>::max();
TFloat d = i;
std::cout
<< std::fixed
<< i << std::endl
<< d << std::endl;
}
int
main()
{
maxint_to_double<int, double>();
maxint_to_double<boost::intmax_t, double>();
maxint_to_double<int, float>();
return 0;
}
Это печатает:
2147483647
2147483647.000000
9223372036854775807
9223372036854775800.000000
2147483647
2147483648.000000
Отметьте как макс. int может вписаться в a double без потери точности и boost::intmax_t (64-разрядный в этом случае), не может. float не может даже содержать int.
Теперь, вопрос: существует ли путь в C++, чтобы проверить, может ли весь диапазон данного целого типа вписаться в тип точки ненависти без потери точности?
Предпочтительно,
- это была бы проверка времени компиляции, которая может использоваться в статическом утверждении,
- и не включил бы перечисление констант, которые компилятор должен знать или может вычислить.
2 ответа
Небольшой предикат:
#include <limits>
template <typename T, typename U>
struct can_fit
{
static const bool value = std::numeric_limits<T>::digits
<= std::numeric_limits<U>::digits;
};
#include <iostream>
int main(void)
{
std::cout << std::boolalpha;
std::cout << can_fit<short, float>::value << std::endl;
std::cout << can_fit<int, float>::value << std::endl;
std::cout << can_fit<int, double>::value << std::endl;
std::cout << can_fit<long long, double>::value << std::endl;
std::cout << can_fit<short, int>::value << std::endl;
std::cout << can_fit<int, short>::value << std::endl;
}
Проверяет, существует ли двоичная точность, доступная в T , в U . Работает на всех типах.
«Усиленный»:
// this is just stuff I use
#include <boost/type_traits/integral_constant.hpp>
template <bool B>
struct bool_type : boost::integral_constant<bool, B>
{
static const bool value = B;
};
typedef const boost::true_type& true_tag;
typedef const boost::false_type& false_tag;
// can_fit type traits
#include <limits>
namespace detail
{
template <typename T, typename U>
struct can_fit
{
static const bool value = std::numeric_limits<T>::digits
<= std::numeric_limits<U>::digits;
};
}
template <typename T, typename U>
struct can_fit : bool_type<detail::can_fit<T, U>::value>
{
typedef T type1;
typedef U type2;
static const bool value = detail::can_fit<T, U>::value;
};
// test
#include <iostream>
namespace detail
{
void foo(true_tag)
{
std::cout << "T fits in U" << std::endl;
}
void foo(false_tag)
{
std::cout << "T does not fit in U" << std::endl;
}
}
// just an example
template <typename T, typename U>
void foo(void)
{
detail::foo(can_fit<T, U>());
}
int main(void)
{
foo<int, double>();
}
Вы можете использовать std :: numeric_limits , чтобы узнать, какая у вас двоичная точность. например:
int binary_digits_double = numeric_limits<double>::digits; // 53
int binary_digits_long_long = numeric_limits<long long>::digits; // 63
int binary_digits_uint = numeric_limits<unsigned int>::digits; // 32