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 <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 бита следующим образом:
{
unsigned int age : 3;
} Age;
Приведённое выше определение структуры сообщает компилятору C, что переменная age будет использовать только 3 бита для хранения этого значения.
Если присвоенное значение превышает диапазон, который могут представить 3 бита, избыточная часть будет подвергнутаусечению(см. пример 2 ниже).
int a:8;
int b:2;
int c:6;
}data;
Приведённый выше код определяет переменную с именемstruct bsstruct, data — это переменная структуры типа bs, занимающая в общей сложности четыре байта.
Для битовых полей их ширина не может превышать размер их типа данных; размер int обычно составляет 4 байта (32 бита).
Когда соседние битовые поля имеют один и тот же тип, если сумма их битовых ширин не превышает размер типа, следующее поле будет сохранено сразу после предыдущего поля, пока оно не перестанет помещаться.
Давайте рассмотрим другой пример:
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
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 <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
Вычислите количество байтов:
Пример
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
Битовые поля позволяют выводить данные в различных форматах.
См. следующий пример:
Пример
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.
Это показывает, что битовые поля также могут использовать указатели.
Другие расширения