The C and C++ standards both allow signed and unsigned variants of the same integer type to alias each other. For example, `unsigned int*` and `int*` may alias. But that's not the whole story because they clearly have a different range of representable values. I have the following assumptions:

* If an `unsigned int` is read through an `int*`, the value must be within the range of `int` or an integer overflow occurs and the behaviour is undefined. Is this correct?
* If an `int` is read through an `unsigned int*`, negative values wrap around as if they were casted to `unsigned int`. Is this correct?
* If the value is within the range of both `int` and `unsigned int`, accessing it through a pointer of either type is fully defined and gives the same value. Is this correct?

Additionally, what about compatible but not equivalent integer types?

* On systems where `int` and `long` have the same range, alignment, etc., can `int*` and `long*` alias? (I assume not.)
* Can `char16_t*` and `uint_least16_t*` alias? I suspect this differs between C and C++. In C, `char16_t` is a typedef for `uint_least16_t` (correct?). In C++, `char16_t` is its own primitive type, which compatible with `uint_least16_t`. Unlike C, C++ seems to have no exception allowing compatible but distinct types to alias.