C/C++ 位域(Bit Fields)

今天中午与同事讨论位域的问题，越讨论越迷糊，最终还是求救Google,找到一些文章，把比较好两篇的转载于下。

---

1. 原文：http://www.cs.cf.ac.uk/Dave/C/node13.html

---

We have seen how pointers give us control over low level memory operations.

Many programs (e.g.systems type applications) must actually operate at a low level where individual bytes must be operated on.

NOTE:The combination of pointers and bit-level operators makes C useful for many low level applications and can almost replace assembly code. (Only about 10 % of UNIX is assembly code the rest is C!!.)

Thebitwiseoperators of C a summarised in the following table:

Table:Bitwise operators

&	AND
	OR
	XOR
	One's Compliment
<<	Left shift
>>	Right Shift

DO NOTconfuse & with &&: & is bitwise AND, &&logicalAND. Similarly forand.

is a unary operator -- it only operates on one argument to right of the operator.

The shift operators perform appropriate shift by operator on the right to the operator on the left. The right operatormustbe positive. The vacated bits are filled with zero (i.e.There isNOwrap around).

For example:x<< 2 shifts the bits inxby 2 places to the left.

So:

ifx= 00000010 (binary) or 2 (decimal)

then:

or 0 (decimal)

Also: ifx= 00000010 (binary) or 2 (decimal)

or 8 (decimal)

Therefore a shift left is equivalent to a multiplication by 2.

Similarly a shift right is equal to division by 2

NOTE: Shifting is much faster than actual multiplication (*) or division (/) by 2. So if you want fast multiplications or division by 2use shifts.

To illustrate many points of bitwise operators let us write a function,Bitcount, that counts bits set to 1 in an 8 bit number (unsigned char) passed as an argument to the function.

int bitcount(unsigned char x) 
{ 
       int count;
 
	for (count=0; x != 0; x>>=1)
		if ( x & 01)
		      count++;
	return count;
}

This function illustrates many C program points:

• for loopnotused for simple counting operation
• xx = x >> 1
• for loop will repeatedly shift rightxuntilxbecomes 0
• use expression evaluation ofx & 01to controlif
• x & 01masksof 1st bit ofxif this is 1 thencount++

Bit Fieldsallow the packing of data in a structure. This is especially useful when memory or data storage is at a premium. Typical examples:

• Packing several objects into a machine word.e.g.1 bit flags can be compacted -- Symbol tables in compilers.
• Reading external file formats -- non-standard file formats could be read in.E.g.9 bit integers.

C lets us do this in a structure definition by putting :bit lengthafter the variable.i.e.

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 funny_int:9;
} pack;

Here thepacked_struct contains 6 members: Four 1 bitflagsf1..f3, a 4 bittypeand a 9 bitfunny_int.

C automatically packs the above bit fields as compactly as possible, provided that the maximum length of the field is less than or equal to the integer word length of the computer. If this is not the case then some compilers may allow memory overlap for the fields whilst other would store the next field in the next word (see comments on bit fiels portability below).

Access members as usual via:

pack.type = 7;

NOTE:

• Onlynlower bits will be assigned to annbit number. So type cannot take values larger than 15 (4 bits long).
• Bit fields arealwaysconverted to integer type for computation.
• You are allowed to mix ``normal'' types with bit fields.
• Theunsigneddefinition is important - ensures that no bits are used as aflag.

Frequently device controllers (e.g.disk drives) and the operating system need to communicate at a low level. Device controllers contain severalregisterswhich may be packed together in one integer (Figure12.1).

Fig.12.1Example Disk Controller RegisterWe could define this register easily with bit fields:

struct DISK_REGISTER  {
     unsigned ready:1;
     unsigned error_occured:1;
     unsigned disk_spinning:1;
     unsigned write_protect:1;
     unsigned head_loaded:1;
     unsigned error_code:8;
     unsigned track:9;
     unsigned sector:5;
     unsigned command:5;
};

To access values stored at a particular memory address,DISK_REGISTER_MEMORYwe can assign a pointer of the above structure to access the memory via:

struct DISK_REGISTER *disk_reg = (struct DISK_REGISTER *) DISK_REGISTER_MEMORY;

The disk driver code to access this is now relatively straightforward:

/* Define sector and track to start read */

disk_reg->sector = new_sector;
disk_reg->track = new_track;
disk_reg->command = READ;

/* wait until operation done, ready will be true */

while ( ! disk_reg->ready ) ;

/* check for errors */

if (disk_reg->error_occured)
  { /* interrogate disk_reg->error_code for error type */
    switch (disk_reg->error_code)
    ......
  }

Bit fields are a convenient way to express many difficult operations. However, bit fields do suffer from a lack of portability between platforms:

• integers may be signed or unsigned
• Many compilers limit the maximum number of bits in the bit field to the size of anintegerwhich may be either 16-bit or 32-bit varieties.
• Some bit field members are stored left to right others are stored right to left in memory.
• If bit fields too large, next bit field may be stored consecutively in memory (overlapping the boundary between memory locations) or in the next word of memory.

If portability of code is a premium you can use bit shifting and masking to achieve the same results but not as easy to express or read. For example:

unsigned int  *disk_reg = (unsigned int *) DISK_REGISTER_MEMORY;

/* see if disk error occured */

disk_error_occured = (disk_reg & 0x40000000) >> 31;

Exercise 12507

Write a function that prints out an 8-bit (unsigned char) number in binary format.

Exercise 12514

Write a function setbits(x,p,n,y) that returns x with the n bits that begin at position p set to the rightmost n bits of an unsigned char variable y (leaving other bits unchanged).

E.g. ifx= 10101010 (170 decimal) andy= 10100111 (167 decimal) andn= 3 andp= 6 say then you need to strip off 3 bits of y (111) and put them in x at position 10xxx010 to get answer 10111010.

Your answer should print out the result in binary form (see Exercise12.1although input can be in decimal form.

Your output should be like this:

   x = 10101010 (binary)
   y = 10100111 (binary)
   setbits n = 3, p = 6 gives x = 10111010 (binary)

Exercise 12515

Write a function that inverts the bits of an unsigned char x and stores answer in y.

Your answer should print out the result in binary form (see Exercise12.1although input can be in decimal form.

Your output should be like this:

   x = 10101010 (binary)
   x inverted = 01010101 (binary)

Exercise 12516

Write a function that rotates (NOT shifts) to the right by n bit positions the bits of an unsigned char x.ie no bits are lost in this process.

Your answer should print out the result in binary form (see Exercise12.1although input can be in decimal form.

Your output should be like this:

   x = 10100111 (binary)
   x rotated by 3 = 11110100 (binary)

Note: All the functions developed should be as concise as possible

---

2. 原文：http://msdn.microsoft.com/en-us/library/ewwyfdbe(v=vs.71).aspx

Classes and structures can contain members that occupy less storage than an integral type. These members are specified as bit fields. The syntax for bit-fieldmember-declaratorspecification follows:

Copy

declaratoropt  : constant-expression

Thedeclaratoris the name by which the member is accessed in the program. It must be an integral type (including enumerated types). Theconstant-expressionspecifies the number of bits the member occupies in the structure. Anonymous bit fields — that is, bit-field members with no identifier — can be used for padding.

NoteAn unnamed bit field of width 0 forces alignment of the next bit field to the nexttypeboundary, wheretypeis the type of the member.

The following example declares a structure that contains bit fields:

Copy

// bit_fields1.cpp
struct Date
{
   unsigned nWeekDay  : 3;    // 0..7   (3 bits)
   unsigned nMonthDay : 6;    // 0..31  (6 bits)
   unsigned nMonth    : 5;    // 0..12  (5 bits)
   unsigned nYear     : 8;    // 0..100 (8 bits)
};

int main()
{
}

The conceptual memory layout of an object of typeDateis shown in the following figure.

Memory Layout of Date Object

Note thatnYearis 8 bits long and would overflow the word boundary of the declared type,unsigned int. Therefore, it is begun at the beginning of a newunsigned int. It is not necessary that all bit fields fit in one object of the underlying type; new units of storage are allocated, according to the number of bits requested in the declaration.

Microsoft Specific

The ordering of data declared as bit fields is from low to high bit, as shown in the figure above.

END Microsoft Specific

If the declaration of a structure includes an unnamed field of length 0, as shown in the following example,

Copy

// bit_fields2.cpp
struct Date
{
   unsigned nWeekDay  : 3;    // 0..7   (3 bits)
   unsigned nMonthDay : 6;    // 0..31  (6 bits)
   unsigned           : 0;    // Force alignment to next boundary.
   unsigned nMonth    : 5;    // 0..12  (5 bits)
   unsigned nYear     : 8;    // 0..100 (8 bits)
};

int main()
{
}

the memory layout is as shown in the following figure.

Layout of Date Object with Zero-Length Bit Field

The underlying type of a bit field must be an integral type, as described inFundamental Types.