Question: I've just recently noticed some of the code in the framework I am working with converts certain variables to doubles and then back when they are accessed by the framework. In the C++11 standard, is this guaranteed to work without loss of precision for any integral types? If so, which? Are there any additional types that are universally safe for this kind of conversion in common implementations?

Also, is there any way to check at compile time that a conversion is safe in this way? Essentially I would like something like:

```
static_assert(T(double(T type))==type);

```

Answer: 
`T(double(T_value))==T_value` is guaranteed when the range of integral type `T` is a subrange of the range of exact integral values of type `double`.

Since no implementation of `double` has 16 bits or less for the mantissa, and since as far as I know there's no extant C++ implementation with more than 16 bits per byte (the `CHAR_BIT` constant from `<limits.h>`), this guarantee holds for `char` and and the explicitly `signed` and `unsigned` variants.

Typically a `double` has some 50+ bits mantissa, and that's enough for the guarantee to hold also for 32-bit integral types, but not for 64-bit.
Well, I (mostly) figured out the second part of my question:

```
#include <limits>
static_assert(T(double(std::numeric_limits<T>::max()))==std::numeric_limits::max(),"ERROR MESSAGE.");

```