Question

I know C++11 has some standard facilities which would allow to get integral values from unaligned memory. How could something like this be written in a more standard way?

template <class R>
inline R get_unaligned_le(const unsigned char p[], const std::size_t s) {
    R r = 0;
    for (std::size_t i = 0; i < s; i++)
        r |= (*p++ & 0xff) << (i * 8); // take the first 8-bits of the char
    return r;
}

To take the values stored in litte-endian order, you can then write:

uint_least16_t value1 = get_unaligned_le<uint_least16_t > (&buffer[0], 2);
uint_least32_t value2 = get_unaligned_le<uint_least32_t > (&buffer[2], 4);

Answer 1

How did the integral values get into the unaligned memory to begin with?
If they were memcpyed in, then you can use memcpy to get them out.
If they were read from a file or the network, you have to know their
format: how they were written to begin with. If they are four byte
big-endian 2s complement (the usual network format), then something
like:

//      Supposes native int is at least 32 bytes...
unsigned
getNetworkInt( unsigned char const* buffer )
{
    return buffer[0] << 24
        |  buffer[1] << 16
        |  buffer[2] <<  8
        |  buffer[3];
}

This will work for any unsigned type, provided the type you’re aiming
for is at least as large as the type you input. For signed, it depends
on just how portable you want to be. If all of your potential target
machines are 2’s complement, and will have an integral type with the
same size as your input type, then you can use exactly the same code as
above. If your native machine is a 1’s complement 36 bit machine (e.g.
a Unisys mainframe), and you’re reading signed network format integers
(32 bit 2’s complement), you’ll need some additional logic.