Jak przesunąć okrąg w tablicy 4 znaków?

Question

Mam tablicę czterech niepodpisanych znaków. Chcę traktować ją jak 32-bitową liczbę (zakładam, że górne bity char nie obchodzą mnie, tylko dbam o niższe 8 bitów). Następnie chcę cyklicznie przesunąć go o dowolną liczbę miejsc. Mam kilka różnych rozmiarów zmian, wszystkie określone podczas kompilacji.

E.g.

unsigned char a[4] = {0x81, 0x1, 0x1, 0x2}; 
circular_left_shift(a, 1); 
/* a is now { 0x2, 0x2, 0x2, 0x5 } */ 

Edit: Aby wszyscy zastanawiać, dlaczego nie wspomnieć CHAR_BIT = 8, ponieważ jest to standardowy C. I nie określił platformę, więc dlaczego zakładając jeden?

Answer 1

static void rotate_left(uint8_t *d, uint8_t *s, uint8_t bits) 
{ 
    const uint8_t octetshifts = bits/8; 
    const uint8_t bitshift = bits % 8; 
    const uint8_t bitsleft = (8 - bitshift); 
    const uint8_t lm = (1 << bitshift) - 1; 
    const uint8_t um = ~lm; 
    int i; 

    for (i = 0; i < 4; i++) 
    { 
     d[(i + 4 - octetshifts) % 4] = 
      ((s[i] << bitshift) & um) | 
      ((s[(i + 1) % 4] >> bitsleft) & lm); 
    } 
} 

Oczywiście

Answer 2

, pamiętając zwykły C Najlepszym sposobem jest

inline void circular_left_shift(char *chars, short shift) { 
    __int32 *dword = (__int32 *)chars; 
    *dword = (*dword << shift) | (*dword >> (32 - shift)); 
} 

Uhmm, char wynosi 16 bitów, nie było jasne dla mnie. Przypuszczam, że int nadal jest 32-bitowy.

inline void circular_left_shift(char *chars, short shift) { 
    int i, part; 
    part = chars[0] >> (16 - shift); 
    for (i = 0; i < 3; ++i) 
     chars[i] = (chars[i] << shift) | (chars[i + 1] >> (16 - shift)); 
    chars[3] = (chars[3] << shift) | part; 
} 

Albo można po prostu odprężyć ten cykl.

Możesz dalej przekopywać się do instrukcji asm ror, na x86 jest w stanie wykonać takie przesunięcie do 31 bitów w lewo. Coś jak

MOV CL, 31 
ROR EAX, CL 

Answer 3

Zastosowanie union:

typedef union chr_int{ 
    unsigned int i; 
    unsigned char c[4]; 
}; 

bezpieczniej (ze względu na wskaźnik aliasing) i łatwiej manipulować.

EDYTOWANIE: powinieneś wcześniej wspomnieć, że twój znak nie ma 8 bitów. Jednakże, należy to zrobić trick:

#define ORIG_MASK 0x81010102 
#define LS_CNT 1 

unsigned char a[4] = { 
    ((ORIG_MASK << LS_CNT  ) | (ORIG_MASK >> (32 - LS_CNT))) & 0xff, 
    ((ORIG_MASK << (LS_CNT + 8)) | (ORIG_MASK >> (24 - LS_CNT))) & 0xff, 
    ((ORIG_MASK << LS_CNT + 16)) | (ORIG_MASK >> (16 - LS_CNT))) & 0xff, 
    ((ORIG_MASK << (LS_CNT + 24)) | (ORIG_MASK >> (8 - LS_CNT))) & 0xff 
};