Bei 2 16-Bit-Ints kann ich diese Bits verschachteln, um ein einzelnes 32-Bit-int zu bilden?

Question

Was ist der richtige Weg dazu? Sagen wir, ich habe ABCD und abcd und die Ausgabebits sollten etwas wie AaBbCcDd sein.

unsigned int JoinBits(unsigned short a, unsigned short b) { } 

Answer 1

#include <stdint.h> 

uint32_t JoinBits(uint16_t a, uint16_t b) { 
    uint32_t result = 0; 
    for(int8_t ii = 15; ii >= 0; ii--){ 
    result |= (a >> ii) & 1; 
    result <<= 1; 
    result |= (b >> ii) & 1; 
    if(ii != 0){ 
     result <<= 1; 
    } 
    } 
    return result; 
} 

auch hier auf ideone getestet: http://ideone.com/lXTqB.

Answer 2

Ohne mathematischen Trick zu nutzen wäre, meine erste naive Lösung sein, eine BitSet wie Datenstruktur zu verwenden, um die Ausgangszahl nach und nach zu berechnen. Dies würde Schleife über lg (a) + lg (b) Bits erfordern, die Ihnen die Komplexität geben würden.

Answer 3

Zuerst verbreiten Sie Ihre Bits:

unsigned int Spread(unsigned short x) 
{ 
    unsigned int result=0; 
    for (unsigned int i=0; i<15; ++i) 
    result |= ((x>>i)&1)<<(i*2); 
    return result; 
} 

Dann werden die beiden mit einem in Ihrer Funktion wie diese Offset fusionieren:

Spread(a) | (Spread(b)<<1); 

Answer 4

Mit etwas Bit-Manipulation durchaus möglich, aber der genaue Code hängt von der byte order der Plattform ab. Unter der Annahme, Little-Endian (das ist die häufigste ist), könnten Sie tun:

unsigned int JoinBits(unsigned short x, unsigned short y) { 
    // x := AB-CD 
    // y := ab-cd 

    char bytes[4]; 

    /* Dd */ bytes[0] = ((x & 0x000F) << 4) | (y & 0x000F); 
    /* Cc */ bytes[1] = (x & 0x00F0) | ((y & 0x00F0) >> 4); 
    /* Bb */ bytes[2] = ((x & 0x0F00) >> 4) | ((y & 0x0F00) >> 8); 
    /* Aa */ bytes[3] = ((x & 0xF000) >> 8) | ((y & 0xF000) >> 12); 

    return *reinterpret_cast<unsigned int *>(bytes); 
} 

Answer 5

Wenn Sie echte bitweise Verschachtelung wollen, könnte die einfachste und elegante Art und Weise dies:

unsigned int JoinBits(unsigned short a, unsigned short b) 
{ 
    unsigned int r = 0; 

    for (int i = 0; i < 16; i++) 
     r |= ((a & (1 << i)) << i) | ((b & (1 << i)) << (i + 1)); 

    return r; 
}