Bit-field

Объявляет член данных класса с явным размером в битах. Смежные битовые поля могут (или не могут) быть упакованы для совместного использования и распределения по отдельным байтам.

Объявление битового поля — это объявление элемента данных класса , которое использует следующий декларатор:

Тип битового поля задаётся decl-specifier-seq в синтаксисе объявления .

Объяснение

Тип битового поля может быть только целочисленным (включая bool ) или (возможно cv-квалифицированным) перечислением, безымянное битовое поле не может быть объявлено с cv-квалифицированным типом.

Битовое поле не может быть статическим элементом данных .

Не существует битовых полей prvalues : преобразование lvalue-to-rvalue всегда производит объект базового типа битового поля.

Количество битов в битовом поле устанавливает предел диапазона значений, которые оно может хранить:

#include <iostream>
struct S
{
    // трёхбитное беззнаковое поле, допустимые значения 0...7
    unsigned int b : 3;
};
int main()
{
    S s = {6};
    ++s.b; // сохраняем значение 7 в битовом поле
    std::cout << s.b << '\n';
    ++s.b; // значение 8 не помещается в это битовое поле
    std::cout << s.b << '\n'; // формально определяется реализацией, обычно 0
}

7
0

Несколько смежных битовых полей обычно упаковываются вместе (хотя это поведение определяется реализацией):

#include <bit>
#include <cstdint>
#include <iostream>
struct S
{
    // обычно занимает 2 байта:
    unsigned char b1 : 3; // первые 3 бита (в 1-м байте) - это b1
    unsigned char    : 2; // следующие 2 бита (в 1-м байте) заблокированы как неиспользуемые
    unsigned char b2 : 6; // 6 бит для b2 - не помещается в 1-й байт => начинается 2-й
    unsigned char b3 : 2; // 2 бита для b3 - следующие (и последние) биты во 2-м байте
};
int main()
{
    std::cout << sizeof(S) << '\n'; // обычно выводит 2
    S s;
    // установить различимые значения полей
    s.b1 = 0b111;
    s.b2 = 0b101111;
    s.b3 = 0b11;
    // показать расположение полей в S
    auto i = std::bit_cast<std::uint16_t>(s);
    // обычно выводит 1110000011110111
    // разбивка:  └┬┘├┘└┬┘└─┬──┘└┤
    //                b1 u  a   b2  b3
    // где "u" обозначает неиспользуемые :2, указанные в структуре, и
    // "a" обозначает добавленное компилятором выравнивание для байтового выравнивания следующего поля.
    // Байтовое выравнивание происходит потому, что тип b2 объявлен как unsigned char;
    // если бы b2 был объявлен как uint16_t, не было бы "a", и b2 примыкал бы к "u".
    for (auto b = i; b; b >>= 1) // вывод младшим битом вперед
        std::cout << (b & 1);
    std::cout << '\n';
}

2
1110000011110111

Специальное безымянное битовое поле нулевого размера может быть использовано для принудительного разрыва выравнивания. Оно указывает, что следующее битовое поле начинается в начале своей единицы распределения:

#include <iostream>
struct S
{
    // will usually occupy 2 bytes:
    // 3 bits: value of b1
    // 5 bits: unused
    // 2 bits: value of b2
    // 6 bits: unused
    unsigned char b1 : 3;
    unsigned char :0; // start a new byte
    unsigned char b2 : 2;
};
int main()
{
    std::cout << sizeof(S) << '\n'; // usually prints 2
                                    // would usually print 1 if not for
                                    // the padding break in line 11
}

2

Если указанный размер битового поля больше размера его типа, значение ограничивается типом: std:: uint8_t b : 1000 ; всё равно будет хранить значения в диапазоне [ ​ 0 ​ , 255 ] . Дополнительные биты являются битами заполнения .

Поскольку битовые поля не обязательно начинаются с начала байта, адрес битового поля не может быть взят. Указатели и неконстантные ссылки на битовые поля невозможны. При инициализации константной ссылки из битового поля создается временный объект (его тип соответствует типу битового поля), копирующий инициализированный значением битового поля, и ссылка привязывается к этому временному объекту.

int a;
const int b = 0;
struct S
{
    // простые случаи
    int x1 : 8 = 42; // OK; "= 42" является brace-or-equal-initializer
    int x2 : 8 {42}; // OK; "{42}" является brace-or-equal-initializer
    // неоднозначности
    int y1 : true ? 8 : a = 42;   // OK; brace-or-equal-initializer отсутствует
    int y2 : true ? 8 : b = 42;   // ошибка: невозможно присвоить значение const int
    int y3 : (true ? 8 : b) = 42; // OK; "= 42" является brace-or-equal-initializer
    int z : 1 || new int{0};      // OK; brace-or-equal-initializer отсутствует
};

Примечания

Следующие свойства битовых полей являются определяемыми реализацией :

• Значение, которое получается при присваивании или инициализации знакового битового поля значением вне диапазона, или при увеличении знакового битового поля за пределы его диапазона.
• Все детали фактического распределения битовых полей внутри объекта класса.

• Например, на некоторых платформах битовые поля не пересекают границы байтов, а на других — пересекают.
• Также, на некоторых платформах битовые поля упаковываются слева направо, а на других — справа налево.

В языке программирования C ширина битового поля не может превышать ширину базового типа, и то, являются ли int битовые поля, которые не объявлены явно как signed или unsigned знаковыми или беззнаковыми, определяется реализацией. Например, int b : 3 ; может иметь диапазон значений [ ​ 0 ​ , 7 ] или [ - 4 , 3 ] в C, но в C++ допустим только последний вариант.

Отчеты о дефектах

Следующие отчеты об изменениях поведения, влияющие на дефекты, были применены задним числом к ранее опубликованным стандартам C++.

Ссылки

Смотрите также