Как получить массив битов в структуре?

НЕ ВОЗМОЖНО – A такая конструкция НЕВОЗМОЖНА(здесь) – НЕ ВОЗМОЖНО

Можно попытаться сделать это, но результатом будет один бит хранится в одном байте

#include <cstdint>
#include <iostream>
using namespace std;

#pragma pack(push, 1)
struct Bit
{
    //one bit is stored in one BYTE
    uint8_t a_:1;
};
#pragma pack(pop, 1)
typedef Bit bit;

struct B
{
    bit bits[4];
};

int main()
{
    struct B b = {{0, 0, 1, 1}};
    for (int i = 0; i < 4; ++i)
        cout << b.bits[i] <<endl;

    cout<< sizeof(Bit) << endl;
    cout<< sizeof(B) << endl;

    return 0;
}

выход:

0 //bit[0] value
0 //bit[1] value
1 //bit[2] value
1 //bit[3] value
1 //sizeof(Bit), **one bit is stored in one byte!!!**
4 //sizeof(B), ** 4 bytes, each bit is stored in one BYTE**

Чтобы получить доступ к отдельным битам из байта, вот пример (Обратите внимание, что расположение битовых полей зависит от реализации)

#include <iostream>
#include <cstdint>
using namespace std;

#pragma pack(push, 1)
struct Byte
{
    Byte(uint8_t value):
        _value(value)
    {
    }
    union
    {
    uint8_t _value;
    struct {
        uint8_t _bit0:1;
        uint8_t _bit1:1;
        uint8_t _bit2:1;
        uint8_t _bit3:1;
        uint8_t _bit4:1;
        uint8_t _bit5:1;
        uint8_t _bit6:1;
        uint8_t _bit7:1;
        };
    };
};
#pragma pack(pop, 1)

int main()
{
    Byte myByte(8);
    cout << "Bit 0: " << (int)myByte._bit0 <<endl;
    cout << "Bit 1: " << (int)myByte._bit1 <<endl;
    cout << "Bit 2: " << (int)myByte._bit2 <<endl;
    cout << "Bit 3: " << (int)myByte._bit3 <<endl;
    cout << "Bit 4: " << (int)myByte._bit4 <<endl;
    cout << "Bit 5: " << (int)myByte._bit5 <<endl;
    cout << "Bit 6: " << (int)myByte._bit6 <<endl;
    cout << "Bit 7: " << (int)myByte._bit7 <<endl;

    if(myByte._bit3)
    {
        cout << "Bit 3 is on" << endl;
    }
}

В С++ вы используете std::bitset<4>. Это позволит использовать минимальное количество слов для хранения и скроет от вас всю маскировку. Очень сложно отделить библиотеку C++ от языка, потому что большая часть языка реализована в стандартной библиотеке. В C нет прямого способа создать такой массив из отдельных битов, вместо этого вы должны создать один элемент из четырех битов или выполнить манипуляции вручную.

РЕДАКТИРОВАТЬ:

1-битное целое число без знака является допустимым типом, так почему бы вам не получить его массив?

На самом деле вы не можете использовать 1-битный беззнаковый тип где-либо, кроме контекста создания члена структуры/класса. В этот момент он настолько отличается от других типов, что автоматически не следует, что вы можете создать их массив.

С++ будет использовать std::vector<bool> или std::bitset<N>.

В C для эмуляции семантики std::vector<bool> вы используете такую ​​структуру:

struct Bits {
    Word word[];
    size_t word_count;
};

где Word — определяемый реализацией тип, равный по ширине шине данных ЦП; wordsize, как будет использоваться позже, равно ширине шины данных.

Например. Word это uint32_fast_t для 32-битных машин, uint64_fast_t для 64-битных машин; wordsize равно 32 для 32-битных машин и 64 для 64-битных машин.

Вы используете функции/макросы для установки/очистки битов.

Чтобы извлечь немного, используйте GET_BIT(bits, bit) (((bits)->)word[(bit)/wordsize] & (1 << ((bit) % wordsize))).

Чтобы установить бит, используйте SET_BIT(bits, bit) (((bits)->)word[(bit)/wordsize] |= (1 << ((bit) % wordsize))).

Чтобы немного очистить, используйте CLEAR_BIT(bits, bit) (((bits)->)word[(bit)/wordsize] &= ~(1 << ((bit) % wordsize))).

Чтобы немного перевернуть, используйте FLIP_BIT(bits, bit) (((bits)->)word[(bit)/wordsize] ^= (1 << ((bit) % wordsize))).

Чтобы добавить изменение размера в соответствии с std::vector<bool>, создайте функцию изменения размера, которая вызывает realloc для Bits.word и соответствующим образом изменяет Bits.word_count. Точные детали этого остаются проблемой.

То же самое относится к правильной проверке диапазона битовых индексов.

это оскорбительно и зависит от расширения... но у меня это сработало:

struct __attribute__ ((__packed__)) A
{
    unsigned int bit0:1;
    unsigned int bit1:1;
    unsigned int bit2:1;
    unsigned int bit3:1;
};
union U
{
    struct A structVal;
    int intVal;
};

int main()
{
    struct A a = {1, 0, 1, 1};
    union U u;
    u.structVal = a;
    for (int i =0 ; i<4; i++)
    {
        int mask = 1 << i;
        printf("%d\n", (u.intVal &  mask) >> i);
    }
    return 0;
}

Вы также можете использовать массив целых чисел (целых или длинных) для построения произвольно большой битовой маски. Системный вызов select() использует этот подход для своего типа fd_set; каждый бит соответствует пронумерованному файловому дескриптору (0..N). Определены макросы: FD_CLR для очистки бита, FD_SET для установки бита, FD_ISSET для проверки бита и FD_SETSIZE для общего количества битов. Макросы автоматически определяют, к какому целому числу в массиве обращаться и к какому биту в целом числе. В Unix см. "sys/select.h"; под Windows, я думаю, он находится в "winsock.h". Вы можете использовать метод FD для создания собственных определений битовой маски. Я полагаю, что в C++ вы могли бы создать объект битовой маски и перегрузить оператор [] для доступа к отдельным битам.

Вы можете создать битовый список, используя указатель структуры. Однако это будет использовать больше, чем бит пространства на бит, поскольку он будет использовать один байт (для адреса) на бит:

struct bitfield{
    unsigned int bit : 1;
};
struct bitfield *bitstream;

Затем после этого:

bitstream=malloc( sizeof(struct bitfield) * numberofbitswewant );

Вы можете получить к ним доступ следующим образом:

bitstream[bitpointer].bit=...