uint8_t型配列からビットを抽出する

Question

私はデータ：ef324ad13255e219e8110044997cefaa43ff0954800000000000007をlfsr[36]というuint8_t型の配列に格納しています。

ビットを配列から抽出したいと思います。ビット番号。 96、ビット番号。 184など

この操作はどのように実行できますか？

Answer 1

を使用することができ、それを説明するために

(lfsr[bit/8] >> (bit % 8)) & 1 

あります：

---

bit/8は、配列から要素を選択します。各要素には8ビットが含まれているため、8で割るとビットインデックスを要素インデックスに簡単に変換できます。

---

bit % 8は、要素内のビットを選択します。これは、インデックス作成の最も簡単な選択肢です。それは、最下位ビットから最上位ビット（リトルエンディアン）までのビットを数えます。別の変種は

7 - bit % 8 

です。この変種は、逆の順序（ビッグエンディアン）でビットをカウントします。互換性の理由からJPEGを使用する必要がある場合があります。どのビットオーダーを自由に選択すれば、リトルエンディアンを使うのが簡単です（より簡単です）。

---

構文(... >> ...) & 1は、数字から1ビットを抽出します。詳細については、hereを参照してください。

Answer 2

マスクとビット単位のANDを試すことができます。たとえば、LSBを取得するには、0x1 &（ビットを抽出する番号）のようにします。バラクマノス、適切なコードによって示されるように第二のをつかんする等0x2の、第三の0x4の、

Answer 3

あろうあなたが同じアレイ

#include <stddef.h> 
#include <stdio.h> 
#include <stdint.h> 

#define MOST_LEFT_BIT_UINT8 (UINT8_MAX/2 + 1) 

int main(void) { 
    uint8_t lfsr[56] = "ef324ad13255e219e8110044997cefaa43ff0954800000000000007"; 

    for (size_t i = 0; i < sizeof lfsr - 1; i++) { 
    for (size_t j = 0; j < 8; j++) { 
     if (lfsr[i] & (MOST_LEFT_BIT_UINT8 >> j)) 
     printf("1"); 
     else 
     printf("0"); 
    } 
    printf(" "); 
    } 
    printf("\n"); 
} 

Answer 4

解決策は次の形式をとります：

(lfsr[byte_idx] >> bit_idx) & 1 

あなたはしかし、私たちはバイトインデックスとビットのインデックスを取得する方法を特定するために十分な情報を提供していませんでした。

• インデックスは0ベース（A、C、E、G）または1ベース（B、D、F、H）ですか？
• lfsr[0]（A、B、C、D）またはlfsr[35]（E、F、G、H）の最初のビットはありますか？
• ビットは、最下位（C、D、G、H）または最上位（A、B、E、F）から番号付けされていますか？これらの

すべての組み合わせは以下のチャートで覆われている：

        A  B  C  D  E  F  G  H 
         +---+             
(lfsr[ 0] >> 7) & 1 | |  0  1  7  8 280 281 287 288 
(lfsr[ 0] >> 6) & 1 | |  1  2  6  7 281 282 286 287 
(lfsr[ 0] >> 5) & 1 | |  2  3  5  6 282 283 285 286 
(lfsr[ 0] >> 4) & 1 | |  3  4  4  5 283 284 284 285 
(lfsr[ 0] >> 3) & 1 | |  4  5  3  4 284 285 283 284 
(lfsr[ 0] >> 2) & 1 | |  5  6  2  3 285 286 282 283 
(lfsr[ 0] >> 1) & 1 | |  6  7  1  2 286 287 281 282 
(lfsr[ 0] >> 0) & 1 | |  7  8  0  1 287 288 280 281 
         +---+             
(lfsr[ 1] >> 7) & 1 | |  8  9 15 16 272 273 279 280 
(lfsr[ 1] >> 6) & 1 | |  9 10 14 15 273 274 278 279 
(lfsr[ 1] >> 5) & 1 | | 10 11 13 14 274 275 277 278 
(lfsr[ 1] >> 4) & 1 | | 11 12 12 13 275 276 276 277 
(lfsr[ 1] >> 3) & 1 | | 12 13 11 12 276 277 275 276 
(lfsr[ 1] >> 2) & 1 | | 13 14 10 11 277 278 274 275 
(lfsr[ 1] >> 1) & 1 | | 14 15  9 10 278 279 273 274 
(lfsr[ 1] >> 0) & 1 | | 15 16  8  9 279 280 272 273 
         +---+             
         | . |             
          .             
         | . |             
         +---+             
(lfsr[34] >> 7) & 1 | | 272 273 279 280  8  9 15 16 
(lfsr[34] >> 6) & 1 | | 273 274 278 279  9 10 14 15 
(lfsr[34] >> 5) & 1 | | 274 275 277 278 10 11 13 14 
(lfsr[34] >> 4) & 1 | | 275 276 276 277 11 12 12 13 
(lfsr[34] >> 3) & 1 | | 276 277 275 276 12 13 11 12 
(lfsr[34] >> 2) & 1 | | 277 278 274 275 13 14 10 11 
(lfsr[34] >> 1) & 1 | | 278 279 273 274 14 15  9 10 
(lfsr[34] >> 0) & 1 | | 279 280 272 273 15 16  8  9 
         +---+             
(lfsr[35] >> 7) & 1 | | 280 281 287 288  0  1  7  8 
(lfsr[35] >> 6) & 1 | | 281 282 286 287  1  2  6  7 
(lfsr[35] >> 5) & 1 | | 282 283 285 286  2  3  5  6 
(lfsr[35] >> 4) & 1 | | 283 284 284 285  3  4  4  5 
(lfsr[35] >> 3) & 1 | | 284 285 283 284  4  5  3  4 
(lfsr[35] >> 2) & 1 | | 285 286 282 283  5  6  2  3 
(lfsr[35] >> 1) & 1 | | 286 287 281 282  6  7  1  2 
(lfsr[35] >> 0) & 1 | | 287 288 280 281  7  8  0  1 
         +---+ 

は、ここでインデックスの各メソッドのためのビットを取得する方法は次のとおりです。

A: int bit96 = (lfsr[     96 /8  ] >> (7 - ( 96 % 8))) & 1; 
B: int bit96 = (lfsr[     (96-1)/8  ] >> (7 - ((96-1) % 8))) & 1; 
C: int bit96 = (lfsr[     96 /8  ] >> (  96 % 8 )) & 1; 
D: int bit96 = (lfsr[     (96-1)/8  ] >> (  (96-1) % 8 )) & 1; 
E: int bit96 = (lfsr[ sizeof(lfsr) - ( 96 /8) - 1 ] >> (7 - ( 96 % 8))) & 1; 
F: int bit96 = (lfsr[ sizeof(lfsr) - ((96-1)/8) - 1 ] >> (7 - ((96-1) % 8))) & 1; 
G: int bit96 = (lfsr[ sizeof(lfsr) - ( 96 /8) - 1 ] >> (  96 % 8 )) & 1; 
H: int bit96 = (lfsr[ sizeof(lfsr) - ((96-1)/8) - 1 ] >> (  (96-1) % 8 )) & 1; 

Gが最も可能性が高いです。 AとBは次に高い可能性があります。 Eは非常にありそうもなく、Fは完全性のためにのみ含まれています。