The probability is 1 - such architectures already existed at the time the
first C standard was written. It was precisely the desire to allow a fully
conforming implementation of C on such a machine that led the C
committee to deliberately avoid imposing any requirements that would
make such an implementation non-conforming, and the C++ committee
chose to follow suit. I unfortunately, cannot provide any examples - I
know about such machines only from second- and third-hand accounts.
The relevant clause from the C standard, which is incorporated by
reference into the C++ standard, says "The pointer returned if the
allocation succeeds is suitably aligned so that it may be assigned to a
pointer to any type of object with a fundamental alignment requirement
and then used to access such an object or an array of such objects in the
space allocated (until the space is explicitly deallocated)." (7.22.3p1).
Because it must be aligned for any object, it must, in particular, be word-
aligned on architectures such as the one described. Therefore, conversion
of the void* value returned by malloc() to int* can safely discard the bits
containing the byte offset within a word, since that byte offset is
guaranteed to be 0. In general, conversion from void* to int* will be lossy
on such a machine, but only for pointers that are not word-aligned, and
the C standard allows for that possibility. For such a conversion "If the
resulting pointer is not correctly aligned for the referenced type, the
behavior is undefined." (126.96.36.199p7).
My experience with the C++ standard suggests that it probably has
wording that is equivalent to 188.8.131.52p7 from the C standard, at least for
code that doesn't make any use of C++-specific features. However,
during a quick search I haven't been able to locate it, probably because it
is worded quite differently.