note_practical_c_programming chapter 11

最新推荐文章于 2021-09-03 23:39:59 发布

彷徨中的一己之见

最新推荐文章于 2021-09-03 23:39:59 发布

阅读量1k

点赞数

分类专栏： Note on C

本文链接：https://blog.csdn.net/hh8856/article/details/26534533

版权

Note on C 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

Practical C Programming                                           Chapter 11

   A bit is the smallest unit of information. Normally, it is represented by the values 1 and 0.
   Eight bits together form a byte, represented by the C data type char.
   C uses the prefix "0x" to indicate a hexademical (base 16) number
       Representation   Number
       Hexadecimal      0x11
       Decimal          17
       Octal            021
       Binary   10001

1. Bit Operators
   Bit operators allow the programmer to work on individual bits
   The bit operators treat each bit as independent
       Operator   Meaning
       &         Bitwise and
       |         Bitwise or
       ^      Bitwise exclusive
       ~       Complement
       <<       Shift left
       >>       Shift right

2. The and Operator (&)
       and operator
       Bit1   Bit2   Bit1 & Bit2
       0 0    0
       0   1 0
       1   0 0
       1   1      1

3. Bitwise or (|)
       or Operator
       Bit1   Bit2   Bit1 | bit2
       0       0 0
       0   1      1
       1   0 1
       1   1    1

4. The Bitwise Exclusive or (^)
       Bit1   Bit2   Bit1 ^ Bit2
       0       0       0
       0         1       1
       1   0       1
       1         1       0

5. The Ones Complement Operator (Not)
       Bit   ~Bit
       0         1
       1   0

6. The left- and Right-Shift Operators
                   c=0x1C   00011100
   c << 1   c=0x38   00111000
   c >> 2   c=0x07   00000111

7. Right-shift Details
          signed char    sined char    unsigned cahr
   Expression   9 >> 2      -8 >> 2        248 >> 2
                 0000 1001    1111 1000        1111 1000
   Result         ??00 0010    ??11 1110    ??11 1110
   Fill         Sign Bit (0)       Sign Bit (1)       Zero
   Final Result 0000 0010       1111 1110   0011 1110
            2            -2             62

8. Setting, Clearing, and Testing Bits

   communications status value
   Name       Description
   ERROR       True if any error is set
   FRAMING_ERROR   A framing error occurred for this character
   PARITY_ERROR   Character had the wrong parity
   CARRIER_LOST   The carrier signal went down
   CHANNEL_DOWN   Power was lost on the communication device

   Bit Assignments
   Bit   Name
   0   ERROR
   1   FRAMING_ERROR
   2   PARITY_ERROR
   3   CARRIER_LOST
   4   CHANNEL_DOWN

   Bit Values
   Bit   Binary Value   Hexadecimal constant
   7   1000 0000   0x80
   6   0100 0000   0x40
   5   0010 0000   0x20
   4   0001 0000   0x10
   3   0000 1000   0x08
   2   0000 0100   0x04
   1   0000 0010   0x02
   0   0000 0001   0x01

   the definition could be:

    /* True if any error is set */
    const int ERROR =    0x01;

    /* A framing error occured for this character */
    const int FRAMING_ERROR =     0x20;

    /* Character had the wrong parity */
    const int PARITY_ERROR =     0x40;

    /* The carrier signal went down */
    const int CARRIER_LOST =    0x08;

    /* Power was lost on the communication device */
    const int CHANNEL_DOWN =    0x10;

this method of defining bits is somewhat confusing. our flags can be defined as:

    /* True if any error is set */
    const int ERROR =    (1 << 0);

    /* A framing error occured for this character */
    const int FRAMING_ERROR =     (1 << 1);

    /* Character had the wrong parity */
    const int PARITY_ERROR =     (1 << 2);

    /* The carrier signal went down */
    const int CARRIER_LOST =    (1 << 3);

    /* Power was lost on the communication device */
    const int CHANNEL_DOWN =    (1 << 4);

to set a bit, use | operator

        char flag = 0;    /* start all flags at 0 */
        
        flag |= CHANNEL_DOWN; /* Channel just died */

to test a bit, we use the & operator to mask out the bits:

        if ((flag & ERROR) != 0) {
            printf("Error flag is set\n");
        } else {
            printf("No error detected\n");
        }

to clear a bit, use not operator with mark then anded it with flag

       flag &= ~PARITY_ERROR;    /* Who cares about parity */

9. Bitmapped graphics
   in bitmapped graphics, each pixel on the screen is represented by a single bit in memory.
   suppose we have a small graphic device -- a 16-by-16-pixel black-and-white display, using a 2-by-16 array of bytes:
   let's see what we need to do to transform our x, y index to a byte_x, byte_y, bit_index, and bit

        byte_y = y;
        byte_x = x / 8;
        bit_index = x % 8;
        bit = 0x80 >> bit_index;
        graphics[byte_x][byte_y] |= bit;

this algorithm can be condensed into a single macro:

        #define set_bit(x,y) graphics[ (x) / 8][y] |= (0x80 >> ((x) % 8))

#include <stdio.h>

#define X_SIZE 40 /* size of array in X direction */
#define Y_SIZE 60 /* size of array in Y direction */

/*
 * We use X_SIZE/8 because we pack 8 bits per byte
 */
char graphics[X_SIZE / 8][Y_SIZE];	/* the graphic data */

#define SET_BIT(x,y) (graphics[(x)/8][y] |= (0x80 >> ((x) % 8)))

int main() {
	int loc;	/* current location we are setting */
	void print_graphics(void);	/* print the data */

	for (loc = 0; loc < X_SIZE; ++loc) {
		SET_BIT(loc, loc);
	}

	print_graphics();
	return 0;
}

/*****************************************************
 * pint_graphics -- Prints the graphics bit array    *
 *             as a set of X and .'s.                *
 ****************************************************/

void print_graphics(void) {
	int x;	/* current X BYTE */
	int y;	/* current y location */
	unsigned int bit;	/* bit we are testing in the current byte */

	for (y = 0; y < Y_SIZE; y++) {
		/* Loop for each byte in the array */
		for (x = 0; x < X_SIZE / 8; ++x) {
			/* handle each bit */
			for (bit = 0x80; bit > 0; bit = (bit >> 1)) {
				if ((graphics[x][y] & bit) != 0) {
					printf("X");
				}
				else {
					printf(" ");
				}
			}
		}
		printf("\n");
	}
}