C Campos de bits
Los campos de bits (bit-field) del lenguaje C son un tipo especial de miembro de estructura que nos permite definir los miembros por bits, especificando el número de bits que ocupan.
Si la estructura del programa contiene múltiples variables de tipo interruptor, es decir, el valor de la variable esTRUE/FALSE, como sigue:
struct
{
unsigned int widthValidated;
unsigned int heightValidated;
} status;
Esta estructura necesita 8 bytes de espacio de memoria, pero en realidad en cada variable solo almacenamos 0 o 1.
En este caso, C proporciona una manera de aprovechar mejor el espacio de memoria: al usar tales variables dentro de la estructura, puede definir el ancho de la variable, indicando al compilador que solo utilizará esos bits.
Por ejemplo, la estructura anterior se puede reescribir como:
struct
{
unsigned int widthValidated : 1;
unsigned int heightValidated : 1;
} status;
Ahora, la variable status solo ocupa 4 bytes de espacio de memoria, pero solo se usan 2 bits para almacenar el valor.
Si se usan 32 variables de 1 bit de ancho, la estructura status todavía ocupa solo 4 bytes; pero una vez que se usan 33 variables, el bit 33 se asigna a la siguiente unidad de memoria, y toda la estructura comienza a ocupar 8 bytes.
Veamos el siguiente ejemplo para entender este concepto:
Ejemplo
#include <string.h>
/* Define una estructura simple */
struct
{
unsigned int widthValidated;
unsigned int heightValidated;
} status1;
/* Define una estructura de campos de bits */
struct
{
unsigned int widthValidated : 1;
unsigned int heightValidated : 1;
} status2;
int main( )
{
printf( "Memory size occupied by status1 : %zu\n", sizeof(status1));
printf( "Memory size occupied by status2 : %zu\n", sizeof(status2));
return 0;
}
Cuando el código anterior se compila y ejecuta, produce los siguientes resultados:
Memory size occupied by status1 : 8 Memory size occupied by status2 : 4
La siguiente tabla resume las características y el uso de los campos de bits:
| Característica | Descripción |
|---|---|
| Especificación del ancho | Al definir un campo de bits, se puede especificar el ancho del campo de bits del miembro, es decir, el número de bits que ocupa el miembro. |
| Límite de ancho | El ancho de un campo de bits no puede exceder el tamaño de su tipo de datos, porque el campo de bits debe ajustarse al tipo entero utilizado. |
| Tipo de datos | En C estándar debe serint、unsigned int、signed inty otros tipos enteros; el uso de otros tipos (como enumeraciones) depende de la implementación del compilador y tiene poca portabilidad. |
| Forma de combinación | Los campos de bits se pueden usar solos o junto con otros miembros normales para formar una estructura. |
| Forma de acceso | Mediante el operador punto (.) o el operador flecha de puntero (->) se accede a ellos, igual que a los miembros normales de la estructura. |
Declaración de campos de bits
Al almacenar cierta información, no es necesario ocupar un byte completo, sino que solo se necesitan unos pocos bits o un bit. Por ejemplo, al almacenar un valor de interruptor, solo hay dos estados, 0 y 1, y basta con 1 bit. Para ahorrar espacio de almacenamiento y simplificar el procesamiento, C proporciona una estructura de datos llamada "campo de bits" o "segmento de bits".
El llamado "campo de bits" consiste en dividir los bits de un byte en varias regiones diferentes y especificar el número de bits de cada región. Cada campo tiene un nombre de campo, lo que permite operar por nombre de campo en el programa. De esta manera, varios objetos diferentes se pueden representar con campos de bits de un byte.
Ejemplo típico: usar 1 bit binario para almacenar un valor de interruptor, con solo dos estados, 0 y 1.
Lectura de formatos de archivo externos: se pueden leer formatos de archivo no estándar, por ejemplo, enteros de 9 bits.
Definición de campos de bits y descripción de variables de campos de bits
La definición de un campo de bits es similar a la definición de una estructura, y su forma es:
struct 位域结构名
{
位域列表
};
La forma de la lista de campos de bits es:
type [member_name] : width ;
A continuación se describen los elementos de las variables en un campo de bits:
| Elemento | Descripción |
|---|---|
| type | Solo puede ser de tres tipos: int (entero), unsigned int (entero sin signo), signed int (entero con signo), lo que determina cómo se interpreta el valor del campo de bits. |
| member_name | El nombre del campo de bits. |
| width | La cantidad de bits en el campo de bits. El ancho debe ser menor o igual al ancho de bits del tipo especificado. |
Las variables con un ancho predefinido se denominancampo de bits. Un campo de bits puede almacenar números de más de 1 bit; por ejemplo, si necesita una variable para almacenar valores del 0 al 7, puede definir un campo de bits de 3 bits de ancho, como se muestra a continuación:
{
unsigned int age : 3;
} Age;
La definición de estructura anterior le indica al compilador C que la variable age usará solo 3 bits para almacenar este valor.
Si el valor asignado excede el rango representable en 3 bits, la parte sobrante setrunca(vea el Ejemplo 2 a continuación).
int a:8;
int b:2;
int c:6;
}data;
El código anterior define unastruct bsestructura llamada bs, data es una variable de estructura de tipo bs, que ocupa cuatro bytes en total.
Para los campos de bits, su ancho no puede exceder el tamaño de su tipo de datos; el tamaño del tipo int suele ser de 4 bytes (32 bits).
Cuando los campos de bits adyacentes son del mismo tipo, si la suma de los anchos no excede el tamaño del tipo, el campo posterior se almacenará inmediatamente después del campo anterior, hasta que ya no quepa.
Veamos otro ejemplo:
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;
El código anterior define una estructura llamada packed_struct, que contiene seis variables miembro; pack es una variable de estructura de tipo packed_struct.
Aquí, packed_struct contiene 6 miembros: cuatro identificadores de 1 bit f1..f4, un type de 4 bits y un my_int de 9 bits.
Veamos el siguiente ejemplo:
Ejemplo 1
struct packed_struct {
unsigned int f1 : 1; // Campo de bits de 1 bit
unsigned int f2 : 1; // Campo de bits de 1 bit
unsigned int f3 : 1; // Campo de bits de 1 bit
unsigned int f4 : 1; // Campo de bits de 1 bit
unsigned int type : 4; // Campo de bits de 4 bits
unsigned int my_int : 9; // Campo de bits de 9 bits
};
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;
}
El ejemplo anterior define una estructura llamada packed_struct, que contiene múltiples miembros de campos de bits.
En la función main, se crea una variable de estructura pack de tipo packed_struct, y se asigna un valor a cada miembro de campo de bits.
Luego se usa la sentencia printf para imprimir el valor de cada miembro de campo de bits.
El resultado de salida es:
f1: 1 f2: 0 f3: 1 f4: 0 type: 7 my_int: 255
Ejemplo 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.age = 8; // En binario es 1000, tiene cuatro bits, excede
printf( "Age.age : %d\n", Age.age );
return 0;
}
El código anterior generará una advertencia de truncamiento al compilar y producirá los siguientes resultados al ejecutarse:
Sizeof( Age ) : 4 Age.age : 4 Age.age : 7 Age.age : 0
Calcular el número de bytes:
Ejemplo
struct example1 {
int a : 4;
int b : 5;
int c : 7;
};
int main() {
struct example1 ex1;
printf("Size of example1: %zu bytes\n", sizeof(ex1));
return 0;
}
En el ejemplo anterior, la estructura example1 contiene tres miembros de campos de bits a, b y c, que ocupan 4, 5 y 7 bits respectivamente.
Usando el operador sizeof se calcula el número de bytes de la estructura example1 y se imprime el resultado:
Size of example1: 4 bytes
Aún hay algunos puntos que aclarar sobre la definición de campos de bits:
-
Los miembros de campos de bits se almacenarán en la misma unidad de almacenamiento en la medida de lo posible; si el espacio restante en esa unidad no es suficiente para el siguiente campo de bits, este se almacenará a partir de la siguiente unidad.
También se puede hacer deliberadamente que un campo de bits comience en la siguiente unidad. Por ejemplo:
struct bs{ unsigned a:4; unsigned :4; /* 空域 */ unsigned b:4; /* 从下一单元开始存放 */ unsigned c:4; };En esta definición de campos de bits, a ocupa 4 bits del primer byte, los 4 bits posteriores se rellenan con 0 para indicar que no se usan, b comienza en el segundo byte y ocupa 4 bits, y c ocupa 4 bits.
El ancho de un campo de bits no puede exceder la longitud del tipo de datos al que está asociado; las variables miembro tienen un tipo, y este tipo limita la longitud máxima de la variable miembro,:el número posterior no puede exceder esta longitud.
-
Un campo de bits puede ser anónimo; en este caso solo se usa para relleno o para ajustar la posición. Un campo de bits anónimo no se puede utilizar. Por ejemplo:
struct k{ int a:1; int :2; /* 该 2 位不能使用 */ int b:3; int c:2; };
Del análisis anterior se puede ver que un campo de bits es esencialmente un tipo de estructura, pero sus miembros se asignan en bits binarios.
Uso de campos de bits
El uso de campos de bits es el mismo que el de los miembros de estructura; su forma general es:
nombre de variable de campo de bits.nombre de campo de bits nombre de variable de campo de bits->nombre de campo de bits
Los campos de bits se pueden imprimir en varios formatos.
Vea el siguiente ejemplo:
Ejemplo
int main(){
struct bs{
unsigned a:1;
unsigned b:3;
unsigned c:4;
} bit,*pbit;
bit.a=1; /* Asignar valor al campo de bits (tenga en cuenta que la asignación no puede exceder el rango permitido del campo) */
bit.b=7; /* Asignar valor al campo de bits (tenga en cuenta que la asignación no puede exceder el rango permitido del campo) */
bit.c=15; /* Asignar valor al campo de bits (tenga en cuenta que la asignación no puede exceder el rango permitido del campo) */
printf("%d,%d,%d\n",bit.a,bit.b,bit.c); /* Imprimir el contenido de los tres campos en formato entero */
pbit=&bit; /* Enviar la dirección de la variable de campo de bits bit al puntero pbit */
pbit->a=0; /* Usando el puntero, reasignar el campo de bits a con el valor 0 */
pbit->b&=3; /* Usa el operador de asignación compuesta bit a bit "&=", equivalente a: pbit->b=pbit->b&3; el valor original del campo b es 7, y el resultado de la operación AND bit a bit con 3 es 3 (111&011=011, valor decimal 3) */
pbit->c|=1; /* Usa el operador compuesto bit a bit "|=", equivalente a: pbit->c=pbit->c|1, cuyo resultado es 15 */
printf("%d,%d,%d\n",pbit->a,pbit->b,pbit->c); /* Usando el puntero, imprime los valores de estos tres campos */
return 0;
}
Cuando el código anterior se compila y ejecuta, produce los siguientes resultados:
1,7,15 0,3,15
En el programa del ejemplo anterior se definió la estructura de campos de bits bs, con tres campos a, b y c, además de una variable bit de tipo bs y una variable puntero pbit que apunta a tipo bs.
Esto indica que los campos de bits también pueden usar punteros.
Otras extensiones