Jak odczytywać / zapisywać dowolne bity W C / C++

Jakieś 2+ lata po tym, jak zadałem to pytanie, chciałbym wyjaśnić je tak, jak chciałbym, aby zostało wyjaśnione, gdy byłem jeszcze kompletnym nowicjuszem i byłoby najbardziej korzystne dla ludzi, którzy chcą zrozumieć proces.

Po pierwsze, zapomnij o przykładowej wartości "11111111", która nie jest tak naprawdę odpowiednia do wizualnego wyjaśnienia procesu. Niech więc wartość początkowa będzie 10111011 (187 dziesiętnych), co będzie nieco bardziej ilustrujące proces.

1 - Jak czytać wartość 3-bitowa zaczynająca się od drugiego bitu:

    ___  <- those 3 bits
10111011 

Wartość jest 101, lub 5 w dziesiętnym, są 2 możliwe sposoby, aby ją uzyskać:

• maska i przesunięcie

W tym podejściu potrzebne bity są najpierw maskowane wartością 00001110 (14 dziesiętnych), po czym są przesuwane w miejsce:

    ___
10111011 AND
00001110 =
00001010 >> 1 =
     ___
00000101

Wyrażenie to brzmiałoby: (value & 14) >> 1

• shift i maska

To podejście jest podobne, ale kolejność operacji jest odwrócona, oznacza to, że oryginalna wartość jest przesunięta, a następnie zamaskowana za pomocą 00000111 (7), aby pozostawić tylko 3 ostatnie bity:

    ___
10111011 >> 1
     ___
01011101 AND
00000111
00000101

Wyrażenie to brzmiałoby: (value >> 1) & 7

Oba podejścia wiążą się z taką samą złożonością, a zatem nie różnią się wydajnością.

2 - Jak napisać wartość 3 bitową zaczynającą się od drugiego bitu:

W tym przypadku wartość początkowa jest znana, a jeśli tak jest w kodzie, możesz wymyślić sposób, aby ustawić znana wartość do innej znanej wartości, która używa mniej operacji, ale w rzeczywistości jest tak rzadko, przez większość czasu kod nie będzie znał ani wartości początkowej, ani tej, która ma być zapisana.

    ___ 
10111011 AND
11110001 (241) =
10110001 (masked original value)

Drugim krokiem jest przesunięcie wartości, którą chcemy zapisać w 3 bity, powiedzmy, że chcemy zmienić to z 101 (5) na 110 (6)

     ___
00000110 << 1 =
    ___
00001100 (shifted "splice" value)

Trzecim i ostatnim krokiem jest połączenie zamaskowanej pierwotnej wartości z przesuniętą wartością "splice":

10110001 OR
00001100 =
    ___
10111101

Wyrażenie dla całego procesu będzie brzmiało: (value & 241) | (6 << 1)

Bonus - jak wygenerować maski odczytu i zapisu:

Oczywiście używanie konwertera binarnego na dziesiętny jest dalekie od elegancji, szczególnie w przypadku kontenerów 32 i 64-bitowych - wartości dziesiętne stają się szalenie Duże. Możliwe jest łatwo generować maski za pomocą wyrażeń, które kompilator może skutecznie rozwiązywać podczas kompilacji:

W ten sposób można odczytać maskę dla "mask and shift": ((1 << fieldLength) - 1) << (fieldIndex - 1), zakładając, że indeks w pierwszym bitie wynosi 1 (nie zero)
• Czytaj maskę dla "shift i maska": (1 << fieldLength) - 1 (Indeks nie odgrywa tu roli, ponieważ zawsze jest przesuwany do pierwszego bitu
• zapis maski: po prostu odwróć wyrażenie maski "maska i przesunięcie" za pomocą operatora ~

Jak to działa (z 3-bitowe pole zaczynające się od drugiego bitu z powyższych przykładów)?

00000001 << 3
00001000  - 1
00000111 << 1
00001110  ~ (read mask)
11110001    (write mask)

Te same przykłady dotyczą szerszych liczb całkowitych oraz dowolnej szerokości i pozycji bitów pól, przy czym wartości przesunięcia i maski są odpowiednio różne.

Zauważ również, że przykłady zakładają unsigned integer, który jest tym, czego chcesz użyć, aby użyć liczb całkowitych jako przenośnej alternatywy pola bitowego( zwykłe pola bitowe nie są w żaden sposób gwarantowane przez standard jako przenośne), zarówno w lewo, jak iw prawo shift insert a padding 0, co nie ma miejsca w przypadku prawego przesunięcia podpisanej liczby całkowitej.

Jeszcze łatwiej:

#define GETMASK(index, size) ((((size_t)1 << (size)) - 1) << (index))
#define READFROM(data, index, size) (((data) & GETMASK((index), (size))) >> (index))
#define WRITETO(data, index, size, value) ((data) = (((data) & (~GETMASK((index), (size)))) | (((value) << (index)) & (GETMASK((index), (size))))))
#define FIELD(data, name, index, size) \
  inline decltype(data) name() const { return READFROM(data, index, size); } \
  inline void set_##name(decltype(data) value) { WRITETO(data, index, size, value); }

Możesz wybrać coś tak prostego jak:

struct A {
  uint bitData;
  FIELD(bitData, one, 0, 1)
  FIELD(bitData, two, 1, 2)
};

I mieć zaimplementowane pola bitowe jako właściwości, do których można łatwo uzyskać dostęp:

A a;
a.set_two(3);
cout << a.two();

Zastąp decltype przez GCC typeof pre-C++11.