C Битовые поля

Битовое поле в языке C — это особый член структуры, который позволяет определять члены по битам и указывать количество занимаемых ими битов.

Если структура программы содержит несколько переменных-переключателей, т. е. значение переменной равноTRUE/FALSE, как показано ниже:

struct
{
  unsigned int widthValidated;
  unsigned int heightValidated;
} status;

Эта структура требует 8 байт памяти, но в действительности мы храним только 0 или 1 в каждой переменной.

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

Например, вышеприведённую структуру можно переписать так:

struct
{
  unsigned int widthValidated : 1;
  unsigned int heightValidated : 1;
} status;

Теперь переменная status занимает только 4 байта памяти, но для хранения значений используется только 2 бита.

Если используются 32 переменные шириной в 1 бит, структура status всё ещё занимает только 4 байта; но как только используются 33 переменные, 33-й бит будет отнесён к следующей единице памяти, и вся структура начнёт занимать 8 байт.

Рассмотрим следующий пример, чтобы понять эту концепцию:

Пример

#include <stdio.h>
#include <string.h>

/* Определить простую структуру */
struct
{
  unsigned int widthValidated;
  unsigned int heightValidated;
} status1;

/* Определить структуру битового поля */
struct
{
  unsigned int widthValidated : 1;
  unsigned int heightValidated : 1;
} status2;
 
int main( )
{
   printf( "Размер памяти, занимаемый status1 : %zu\n", sizeof(status1));
   printf( "Размер памяти, занимаемый status2 : %zu\n", sizeof(status2));

   return 0;
}

Когда приведенный выше код скомпилирован и выполнен, он выдает следующие результаты:

Memory size occupied by status1 : 8
Memory size occupied by status2 : 4

В следующей таблице обобщены характеристики и использование битовых полей:

ОсобенностиОписание
Указание шириныПри определении битового поля можно указать ширину битового поля для члена, т. е. количество битов, которое занимает член.
Максимальная ширинаШирина битового поля не может превышать размер его типа данных, поскольку битовое поле должно помещаться в используемый целочисленный тип.
Типы данныхВ стандартном C это должны бытьint、unsigned int、signed intцелочисленные типы и т. д. Использование других типов (например, перечислений) зависит от реализации компилятора и менее переносимо.
Способ комбинированияБитовые поля можно использовать отдельно или объединять в структуру вместе с другими обычными членами.
Способ доступаЧерез оператор точки (.) или оператор стрелки для указателей (->) доступ, таким же образом, как к обычным элементам структуры.

Объявление битового поля

Некоторой информации при хранении не нужно занимать целый байт; достаточно нескольких битов или одного бита. Например, при хранении значения переключателя есть только два состояния, 0 и 1, поэтому достаточно 1 бита. Чтобы сэкономить место для хранения и упростить обработку, C предоставляет структуру данных, называемую «битовым полем» или «битовым сегментом».

Так называемое «битовое поле» делит биты в байте на несколько различных областей и задаёт количество битов в каждой области. Каждое поле имеет имя поля, что позволяет выполнять операции по имени поля в программе. Таким образом, несколько различных объектов могут быть представлены двоичными битовыми полями одного байта.

Типичный пример: использование 1 двоичного бита для хранения значения переключателя, которое имеет только два состояния: 0 и 1.

Чтение внешних файловых форматов — можно читать нестандартные форматы файлов, например 9-битные целые числа.

Определение битовых полей и описание переменных битовых полей

Определение битового поля похоже на определение структуры, и его форма такова:

struct 位域结构名 
{

 位域列表

};

Список битовых полей имеет следующий вид:

type [member_name] : width ;

Ниже приведено описание переменных элементов битового поля:

элементОписание
typeДопускается только int (целое число), unsigned int (беззнаковое целое) или signed int (знаковое целое), что определяет, как интерпретируется значение битового поля.
member_nameИмя битового поля.
widthКоличество битов в битовом поле. Ширина должна быть меньше или равна битовой ширине указанного типа.

Переменные с заранее заданной шириной называютсябитовыми полями. Битовые поля могут хранить числа больше 1 бита. Например, если вам нужна переменная для хранения значений от 0 до 7, можно определить битовое поле шириной 3 бита следующим образом:

struct
{
  unsigned int age : 3;
} Age;

Приведённое выше определение структуры сообщает компилятору C, что переменная age будет использовать только 3 бита для хранения этого значения.

Если присвоенное значение превышает диапазон, который могут представить 3 бита, избыточная часть будет подвергнутаусечению(см. пример 2 ниже).

struct bs{
    int a:8;
    int b:2;
    int c:6;
}data;

Приведённый выше код определяет переменную с именемstruct bsstruct, data — это переменная структуры типа bs, занимающая в общей сложности четыре байта.

Для битовых полей их ширина не может превышать размер их типа данных; размер int обычно составляет 4 байта (32 бита).

Когда соседние битовые поля имеют один и тот же тип, если сумма их битовых ширин не превышает размер типа, следующее поле будет сохранено сразу после предыдущего поля, пока оно не перестанет помещаться.

Давайте рассмотрим другой пример:

span style="color: #993333;">struct packed_struct {
  unsigned int f1:1;
  unsigned int f2:1;
  unsigned int f3:1;
  unsigned int f4:1;
  unsigned int type:4;
  unsigned int my_int:9;
} pack;

Приведённый выше код определяет структуру с именем packed_struct, которая содержит шесть переменных-членов; pack — это переменная структуры типа packed_struct.

Здесь packed_struct содержит 6 членов: четыре 1-bit идентификатора f1..f4, 4-bit type и 9-bit my_int.

Давайте рассмотрим следующий пример:

Пример 1

#include <stdio.h>

struct packed_struct {
   unsigned int f1 : 1;   // 1-bit битовое поле
   unsigned int f2 : 1;   // 1-bit битовое поле
   unsigned int f3 : 1;   // 1-bit битовое поле
   unsigned int f4 : 1;   // 1-bit битовое поле
   unsigned int type : 4; // 4-bit битовое поле
   unsigned int my_int : 9; // 9-bit битовое поле
};

int main() {
   struct packed_struct pack;

   pack.f1 = 1;
   pack.f2 = 0;
   pack.f3 = 1;
   pack.f4 = 0;
   pack.type = 7;
   pack.my_int = 255;

   printf("f1: %u\n", pack.f1);
   printf("f2: %u\n", pack.f2);
   printf("f3: %u\n", pack.f3);
   printf("f4: %u\n", pack.f4);
   printf("type: %u\n", pack.type);
   printf("my_int: %u\n", pack.my_int);

   return 0;
}

Приведённый выше пример определяет структуру с именем packed_struct, которая содержит несколько членов битовых полей.

В функции main создаётся переменная структуры pack типа packed_struct, и каждому члену битового поля присваивается значение.

Затем с помощью операторов printf выводятся значения каждого члена битового поля.

Вывод:

f1: 1
f2: 0
f3: 1
f4: 0
type: 7
my_int: 255

Пример 2

#include <stdio.h>
#include <string.h>

struct
{
  unsigned int age : 3;
} Age;

int main( )
{
   Age.age = 4;
   printf( "Sizeof( Age ) : %zu\n", sizeof(Age) );
   printf( "Age.age : %d\n", Age.age );

   Age.age = 7;
   printf( "Age.age : %d\n", Age.age );

   Возраст.age = 8; // Двоичное представление — 1000, оно содержит четыре бита, что превышает допустимый диапазон
   printf( "Age.age : %d\n", Age.age );

   return 0;
}

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

Sizeof( Age ) : 4
Age.age : 4
Age.age : 7
Age.age : 0

Вычислите количество байтов:

Пример

#include <stdio.h>

struct example1 {
   int a : 4;
   int b : 5;
   int c : 7;
};

int main() {
   struct example1 ex1;

   printf("Размер example1: %zu байт\n", sizeof(ex1));

   return 0;
}

В приведённом выше примере структура example1 содержит три члена битовых полей a, b и c, занимающих соответственно 4 бита, 5 бит и 7 бит.

Используйте оператор sizeof для вычисления количества байтов структуры example1 и выведите результат:

Size of example1: 4 bytes

Относительно определения битовых полей следует пояснить следующие моменты:

  • Члены битовых полей будут пытаться храниться в одной и той же единице хранения. Если оставшегося пространства в этой единице недостаточно для размещения следующего битового поля, битовое поле будет сохранено начиная со следующей единицы.

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

    struct bs{
        unsigned a:4;
        unsigned  :4;    /* 空域 */
        unsigned b:4;    /* 从下一单元开始存放 */
        unsigned c:4;
    };

    В этом определении битового поля a занимает 4 бита первого байта, следующие 4 бита заполнены 0, чтобы указать, что они не используются, b начинается со второго байта и занимает 4 бита, а c занимает 4 бита.

  • Ширина битового поля не может превышать длину типа данных, от которого оно зависит. Все переменные-члены имеют типы, и этот тип ограничивает максимальную длину переменной-члена.:Следующие числа не могут превышать эту длину.

  • Битовое поле может быть безымянным битовым полем, в этом случае оно используется только для заполнения или выравнивания позиции. Безымянные битовые поля нельзя использовать. Например:

    struct k{
        int a:1;
        int  :2;    /* 该 2 位不能使用 */
        int b:3;
        int c:2;
    };

Из приведённого выше анализа видно, что битовое поле по сути является структурным типом, только его члены выделяются побитно.

Использование битовых полей

Использование битовых полей такое же, как использование членов структуры; его общая форма такова:

bit-field variable name.bit-field name
bit-field variable name->bit-field name

Битовые поля позволяют выводить данные в различных форматах.

См. следующий пример:

Пример

#include <stdio.h>

int main(){
    struct bs{
        unsigned a:1;
        unsigned b:3;
        unsigned c:4;
    } bit,*pbit;
    bit.a=1;    /* Присвойте значение битовому полю (обратите внимание, что присваиваемое значение не должно выходить за допустимый диапазон битового поля) */
    bit.b=7;    /* Присвойте значение битовому полю (обратите внимание, что присваиваемое значение не должно выходить за допустимый диапазон битового поля) */
    bit.c=15;   /* Присвойте значение битовому полю (обратите внимание, что присваиваемое значение не должно выходить за допустимый диапазон битового поля) */
    printf("%d,%d,%d\n",bit.a,bit.b,bit.c);     /* Вывести содержимое трёх полей в целочисленном формате */
    pbit=&bit;  /* Присвойте адрес переменной битового поля bit переменной-указателю pbit */
    pbit->a=0;  /* Используйте указатель, чтобы присвоить битовому полю a значение 0 */
    pbit->b&=3; /* Использует составной битовый оператор "&=", эквивалентный: pbit->b=pbit->b&3. Исходное значение битового поля b равно 7, а побитовое И с 3 даёт 3 (111&011=011, десятичное значение 3) */
    pbit->c|=1; /* Использует составной битовый оператор "|=", эквивалентный: pbit->c=pbit->c|1, и результат равен 15 */
    printf("%d,%d,%d\n",pbit->a,pbit->b,pbit->c);       /* Выведите значения этих трёх полей с помощью указателей */
    return 0;
}

Когда приведенный выше код скомпилирован и выполнен, он выдает следующие результаты:

1,7,15
0,3,15

В приведённой выше примерной программе определена структура bs с тремя битовыми полями a, b, c, а также переменная bit типа bs и переменная-указатель pbit, указывающая на тип bs.

Это показывает, что битовые поля также могут использовать указатели.

Другие расширения