Ich musste das in der Vergangenheit schon oft machen und war mit den Ergebnissen noch nie zufrieden.

Kann jemand einen schnellen Weg zum Kopieren eines zusammenhängenden Bit-Arrays von der Quelle zum Ziel vorschlagen, bei dem sowohl die Quelle als auch das Ziel möglicherweise nicht an geeigneten Prozessorgrenzen ausgerichtet (nach rechts verschoben) sind?

Wenn sowohl die Quelle als auch das Ziel nicht ausgerichtet sind, kann das Problem schnell in ein Problem geändert werden, bei dem nur eines von beiden nicht ausgerichtet ist (nach dem ersten Ausdruck).

Als Ausgangspunkt sieht mein Code unweigerlich wie folgt aus (ungetestet, Nebeneffekte ignorieren, dies ist nur ein Beispiel, das von der Stulpe abweicht):

const char mask[8] = { 1, 3, 7, 15, 31, 63, 127, 255 };
/* Assume:
 * - destination is already zeroed,
 * - offsets are right shifts
 * - bits to copy is big (> 32 say)
 */
int bitarray_copy(char * src, int src_bit_offset, int src_bit_len,
                  char * dst, int dst_bit_offset) {
    if (src_bit_offset == dst_bit_offset) { /* Not very interesting */ 
    } else {
        int bit_diff_offset = src_bit_offset - dst_bit_offset; /* assume positive */
        int loop_count;
        char c;
        char mask_val = mask[bit_diff_offset];

        /* Get started, line up the destination. */
        c  = (*src++ << bit_diff_offset) | ((*src >> (8 - bit_diff_offset)) & mask_val);
        c &= mask[8-dst_bit_offset];

        *dst++ |= c;

        src_bit_len -= 8 - dst_bit_offset;
        loop_count = src_bit_len >> 3;

        while (--loop_count >= 0) 
            * dst ++ = (*src++ << bit_diff_offset) | ((*src >> (8 - bit_diff_offset)) & mask_val);

        /* Trailing tail copy etc ... */
        if (src_bit_len % 8) /* ... */
    }
}

(eigentlich ist das besser als ich es vorher getan habe. Es sieht nicht schlecht aus)