Detailed introduction to C language bit segments

Bit segment in C language

Bit-field defines the space occupied by member variables in a structure (or union) in units of bits. A structure (union) containing bit segments is called a bit segment structure. The segmented structure can save space and facilitate operation.

The definition format of bit field is:

type [var]: digits

Where type can only be int, unsigned int, signed There are three types of int (whether the int type can represent negative numbers depends on the compiler. For example, int in VC defaults to signed int, can represent negative numbers). The bit field name var is an optional parameter and can be omitted. digits represents the number of binary digits occupied by this bit field.

Then defining a bit segment structure can be defined like the following code:

struct node 
{   unsigned int a:4;   //位段a，占4位  
    unsigned int :0;   //无名位段，占0位   
    unsigned int b:4;   //位段b，占4位   
    int c:32;       //位段c，占32位   
    int :6;       //无名位段，占6位 
    };

1. Use of bit segments

There are a few points to note when using bit segments:

1) The type of bit segment can only be int. There are three types of unsigned int and signed int, which cannot be char type or floating point type;

2) The number of binary digits occupied by the bit field cannot exceed the maximum number of digits that can be represented by the basic type. For example, int in VC accounts for 4 Bytes, then it can only be 32 bits at most;

3) The unnamed bit field cannot be accessed, but it will occupy space;

4) The address cannot be obtained for the bit field;

5) If the number of binary digits occupied by a bit field is 0, then this bit field must be an unnamed bit field, and the next bit field is stored in the next bit field storage unit (the number of bit field storage units here has been tested to be 4 in the VC environment) Byte) starts to be stored;

6) If the bit field appears in the expression, it will be automatically upgraded to integer type and converted to int type or unsigned int.

7) When assigning a value to a bit segment, it is best not to exceed the maximum range that the bit segment can represent, otherwise unexpected results may occur.

8) The bit field cannot be in the form of an array.

2. How bit segment structures are stored in memory

For bit segment structures, the compiler will automatically optimize the storage space. The main principles are:

1) If a bit segment storage unit can store all members in the lower bit segment structure, then all members in the bit segment structure can only be placed in one bit segment storage unit and cannot be placed in two bit segment storage units; if If one bit segment storage unit cannot accommodate all the members in the lower bit segment structure, then the remaining bit segments will be stored starting from the next bit segment storage unit. (The size of the segment storage unit in VC is 4 bytes).

2) If there is only one unnamed bit segment occupying 0 bits in a bit segment structure, it only occupies 1 or 0 bytes of space (0 bytes in C language, and 1 byte in C++); otherwise, any other In this case, the space occupied by a bit segment structure is at least the size of a bit segment storage unit;

Test program:

/*测试位段 201110.12*/ 
#include<iostream> 
using namespace std;    
typedef struct node 
{   
unsigned int a:1;   //存在一个非0位的位段，则至少占4Byte  
}S;    
typedef struct node1    //在C++中占1字节的空间 ，在C中占0字节  
{   
unsigned int :0; 
}S1;   
typedef struct node2 
{   
unsigned int a:1;   
unsigned int :0;   //下一个位段放在一个新的位段存储单元 ，所以占4+4=8Byte    
unsigned c:32;      
}S2;   
typedef struct node3 
{   
 unsigned int a:4;   
 unsigned int :0;   
 int :6; //这个位段放在一个新的位段存储单元    
 unsigned c:32;//由于6+32>32，所位段c也放在一个新的位段存储单元，所以占4+4+4=12Byte  
}S3;   
typedef struct node4  
{   
unsigned int a:1;   
char b;  //在一个位段存储单元中能够存下所有的成员，所以占4Byte    
int c:1;   int d:2;   unsigned int e:2; 
}S4;     
nt main(int argc, char *argv[]) 
{   
S4 s4;   
s4.a=1;   
s4.c=1;   
s4.d=2;          
s4.e=3;   
printf("%d %d %d %d\n",s4.a,s4.c,s4.d,s4.e);   
printf("%d %d %d %d %d\n",sizeof(S),sizeof(S1),sizeof(S2),sizeof(S3),sizeof(S4));   
return 0; 
}

The execution result is:

1 -1 -2 3
4 1 8 12 4
Please press Any key continues. . .
When printing each bit field of s4, the printed result is different from the assigned initial value.

Since c only occupies 1 bit, there is no data bit. At this time, sign extension is performed to directly add 1 to the high bit, so the printed result is -1;

Since d occupies 2 bits, then when 2 is assigned to d, The content stored in the memory is 10. At this time, sign extension is performed, and the high bit is supplemented by 1, then it is 0XFF FF FF FE, then its true value is -2.

Thanks for reading, I hope it can help everyone, thank you for your interest in this site support!