Zugriff auf bits in einem char in C

Wenn Sie & Ihre Nummer mit 0x03, erhalten Sie die letzten zwei bits.

char c = 0x37;
char mask = 0x03;
char lastTwo = c & mask;

InformationsquelleAutor dasblinkenlight

Könnte man auch verwenden, bit-Felder, dies zu tun. Der schlechte Teil über das bit-Felder, die genau wie Sie funktionieren, ist etwas compiler-abhängig, aber wenn Sie nicht brauchen, um das portieren von code auf vielen Architekturen ist es vielleicht in Ordnung.

Hier ist ein Beispiel, geschrieben auf einer Ubuntu-Linux-Rechner und getestet mit GCC.

#include <assert.h>
#include <stdio.h>

#pragma pack(1)
typedef struct
{
    unsigned int low2: 2;  //2 bits of the byte
    unsigned int high6: 6;  //6 more bits of the byte
} MYBYTE;

typedef union
{
    MYBYTE mybyte;
    unsigned char b;
} MYUNION;

main()
{
    MYUNION m;

    assert(sizeof(m) == 1);
    m.b = 0x03;
    assert(m.mybyte.low2 == 0x03);
    assert(m.mybyte.high6 == 0x00);

    printf("low2 of 0x03 is: %u\n", m.mybyte.low2);
    printf("high6 of 0x03 is: %u\n", m.mybyte.high6);

    m.b = 0xff;

    printf("low2 of 0x03 is: %u\n", m.mybyte.low2);
    printf("high6 of 0x03 is: %u\n", m.mybyte.high6);
    assert(m.mybyte.low2 == 0x03);
    assert(m.mybyte.high6 == 0x3f);

    m.mybyte.high6 = 0x1c;
    m.mybyte.low2 = 0x01;
    assert(m.b == 0x71);
    printf("m.b is: 0x%02x\n", m.b);

    return 0;
}

Die union ist da, also können wir es als full-byte, oder es von bit-Feldern. #pragma pack(1) ist, sicherzustellen, dass die bit-Felder-pack nach unten in ein byte, kein extra "padding" - bits. (Wie ich schon sagte, Sie befinden sich auf Implementierungsdetails wenn Sie bit-Feldern).

Aber schauen Sie, wie einfach und sauber es ist, um die bits, die Sie möchten. Schreiben Sie in ganzen byte-und Auslesen der bits, die Sie wollen, oder schreiben Sie in den bits, die Sie möchten, und Lesen Sie die ganze byte.

Wenn Sie gehen, verwenden Sie code wie diesen, ist es immer eine gute Idee, haben einige behauptet, dass stellen Sie sicher, es ist Arbeit.

Wenn Sie nicht benutzt bit-Felder, schlage ich vor, Sie definieren eine Funktion, die Ihre Verschiebung und Maskierung für Sie, um sicherzustellen, dass Sie nicht mess up. Vielleicht so etwas wie dieses:

#include <limits.h>


static unsigned int _bit_masks[] =
{
    0x00000000, 0x00000001, 0x00000003, 0x00000007,
    0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f,
    0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff,
    0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff,
    0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff,
    0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff,
    0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff,
    0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff,
};


#define MIN(a, b) \
    ((a) < (b) ? (a) : (b))

unsigned int
bits(unsigned int x, unsigned int i_bit, unsigned int c_bits)
{
    assert(UINT_MAX >= 4294967295U); //unsigned int must be at least 32-bit
    assert(i_bit <= 31);
    if (i_bit > 31)
        return 0;
    c_bits = MIN(c_bits, 32 - i_bit);

    //shift-and-mask to grab the requested bits, and return those bits
    return (x >> i_bit) & _bit_masks[c_bits];
}

Übergeben Sie einen Wert, dann wird die bit-position, die Sie wollen, bits aus, und wie viele bits Sie wollen. So greifen 6 bits beginnend von der bit-position 2, mit einem test-Wert von 0x71, könnte man sagen:

x = bits(0x71, 2, 6);  //x is set to 0x1c

Wenn Sie nicht wie die lookup-Tabelle, und Sie wollen den kleinsten code, um dies zu tun, können Sie verwenden:

unsigned int
bits(unsigned int x, unsigned int i_bit, unsigned int c_bits)
{
    const unsigned int mask_bits = 0xffffffff;

    assert(UINT_MAX >= 4294967295U); //unsigned int must be at least 32-bit
    assert(i_bit <= 31);
    if (i_bit > 31)
        return 0;
    c_bits = MIN(c_bits, 32 - i_bit);

    //shift-and-mask to grab the requested bits, and return those bits
    return (x >> i_bit) & (mask_bits >> (32 - c_bits));
}

Müssen Sie sicherstellen, dass die mask-bits erklärt unsigned denn wenn Sie signiert sind, die rechts-shift-operation Unterschreiben zu erweitern.

Wenn Sie erklären, dass diese Letzte version der Funktion, die als inline -, legen Sie es in header-Dateien, und rufen Sie es mit Konstanten Werten für i_bit und c_bits es kompilieren wird bis zu einem minimalen code, um das problem zu lösen. (Zum Beispiel, wenn i_bit ist 0, der compiler weiß, dass >> 0 tut nichts und wird einfach nicht generieren, code. Und wenn der compiler weiß c_bits als eine Konstante ist, kann es tun all die Arbeit, die Verlagerung mask_bits zur compile-Zeit.) Aber Sie müssen sicherstellen, dass Sie über eine version von assert() für die Kompilierung entfernt, um nichts in der release-Version, oder benutzen Sie Ihre eigenen ASSERT() makro-und machen Sie Ihr makro kompilieren Weg zu nichts.

InformationsquelleAutor steveha

Dies ist die einfachste Funktion zu verwenden, ich will nicht andere zum Kampf für eine lange Zeit, bevor man etwas wie dies hier -

char get_bits(char a, char no_of_bits)
{
    return a & ((no_of_bits << 1) - 1);
}
char a = 0x37;
char b = get_bits(a, 2);

Hoffe es hilft jemandem in Zukunft

InformationsquelleAutor Thomas