1. Binary, bit and byte

• Numbers based on 2 are called binary number s

1		  1		 	0		  1
1 * 2^3 + 1 * 2^2 + 0 * 2^1 + 1 * 2^0 = 13

1.1 binary integer

• C language uses byte s to represent the required size of the character set of the storage system

  • 1 byte = 8 bits

• Interpret bit pattern s in different ways for 1 byte (8 bits)

  • unsigned char: 0000 0000 ~ 1111 1111 = 0 ~ 255

  • signed char : 1000 0000 ~ 0111 1111 = -128 ~ 127

1.2 signed integer

• Sign magnitude representation: 1 bit * * high order bit) * * stores symbols, and the remaining 7 bits represent the number itself

  • 1111 1111 ~ 0111 1111 = -127 ~ 127
  • There are two zeros:
    • 0000 0000 = +0
    • 1000 0000 = -0

• two's-complement method: take the inverse and add 1

  • 1111 1111 ~ 0111 1111 = -128 ~ 127

• Inverse binary (one's) method

  • 1000 0000 ~ 0111 1111 = -127 ~ 127
  • There are two zeros:
    • 0000 0000 = +0
    • 1111 1111 = -0

1.3 binary floating point number

• Floating point numbers are stored in two parts
  • Binary decimal
  • Binary index

1.3.1 binary decimal

• Take the power of 2 as the denominator

1	  0		1
1/2 + 0/4 + 1/8 = 0.625

• Many fractions cannot be accurately represented by binary decimals
  • It can only accurately represent the sum of multiple 1 / 2 powers

1.3.2 floating point representation

• Several bits store binary fractions, while others store exponents

2. Other hexadecimal numbers

• Octal and hexadecimal numeration systems are usually used

2.1 octal

• Octal refers to the octal numeration system
• Numbers based on 8

4		  5			1
4 * 8^2 + 5 * 8^1 + 1 * 8^0 = 297

• Each octal bit corresponds to three binary bits

  • Binary equivalent to octal

    Octal digit	Equivalent binary bit
    0	000
    1	001
    2	010
    3	011
    4	100
    5	101
    6	110
    7	111

2.2 hex

• Hexadecimal (hex decimal or hex) refers to the hexadecimal numeration system
• Numbers are represented on the basis of 16

A			3			F
10 * 16^2 + 3 * 16^1 + 15 * 16^0 = 2623

• Each hexadecimal bit corresponds to 4 binary bits

  • Decimal, hexadecimal, and binary equivalents

    decimal system	hexadecimal	Equivalent binary
    0	0	0000
    1	1	0001
    2	2	0010
    3	3	0011
    4	4	0100
    5	5	0101
    6	6	0110
    7	7	0111
    8	8	1000
    9	9	1001
    10	A	1010
    11	B	1011
    12	C	1100
    13	D	1101
    14	E	1110
    15	F	1111

3. C bitwise operator

3.1 bitwise logical operators

• bitwise operation: the operation is carried out for each bit and does not affect the bits on the left and right sides

3.1.1 binary inversion or bit inversion:~

• Change 1 to 0, change 0 to 1
• The operator does not change the original value

char c = 0b10011010;
~c;
printf("%d\n%d\n", c, ~c);
// ~(1001 1010) = -102
//   0110 0101  = 101

3.1.2 bitwise AND:&

• The same is 1

char c1 = 0b10010011;
char c2 = 0b00111101;
printf("%d\n", c1 & c2);
// 1001 0011
// 0011 1101
// &
// 0001 0001

3.1.3 by bit or:|

• If there is 1, it is 1

char c1 = 0b10010011;
char c2 = 0b00111101;
printf("%d\n", c1 | c2);
// 1001 0011
// 0011 1101
// |
// 1011 1111

3.1.4 bitwise XOR:^

• The difference is 1

char c1 = 0b10010011;
char c2 = 0b00111101;
printf("%d\n", c1 ^ c2);
// 1001 0011
// 0011 1101
// ^
// 1010 1110

3.7 shift operator

3.7.1 move left:<<

• Moves the object to the left of the operator to the left and the number of bits specified by the object to the right
• The operator does not change the original value

char c = 0b10001010;
c << 2;
printf("%d\n%d\n", c, c << 2);
// 00 1000 1010
// 10 0010 1000
//    High level truncation
//    0010 1000

3.7.2 shift right: > >

• Moves the object to the left of the operator to the right, and the number of bits specified by the object to the right
• The operator does not change the original value

char c = 0b10001010;
c >> 2;
printf("%d\n%d\n", c, c >> 2);
// 1000 1010
// 1110 0010 10
// Low truncation
// 1110 0010

3.7.3 usage: shift operator

• Provides fast multiplication and division for powers of 2
  • Number < < n: number is multiplied by 2 to the nth power
  • Number > > n: if number is nonnegative, divide number by the nth power of 2

4. Bit field

• A bit field is a set of adjacent bits in a signed int or unsigned int type variable
• Build through a structure declaration

struct {
    int a : 1;
    int b : 2;
    int c : 3;
} abc;
// abc is a field containing three 1 bits

abc.a = 0;
abc.c = 1;
// Since the number of digits in the field is 1, it can only be assigned 0 or 1

• If the total number of bits declared exceeds the number of bits of int (unsigned int is the same), the storage location of the next int will be used

  • When this happens, an unnamed "hole" is left in the first int
  • Unnamed "holes" can be "filled" with unnamed field widths
  • Use an unnamed field with a width of 0 to store the next field in the next int

  struct {
      int a : 1;
      int   : 2;
      int b : 2;
      int   : 0;
      int c : 3;
  } abc;
  // There is a 2-digit gap between a and b
  // c will be stored in the next int z