A byte

• Is a group of eight consecutive bits (Image-1)
• The bits are counted from right to left starting at 0
• Is considered as being made of two nibbles (Image-2)

 The most right bit

• Is bit 0
• It is called the least significant bit
• It is also referred to as the Low Order bit, the LO bit, or LOBIT

The most left bit

• Is bit 7
• It is called the most significant bit
• It is also referred to as the High Order bit, the HI bit, or HIBIT

The other bits

• Are referred to following their positions

(Image-2)

The right nibble (Image-2)

• Made of the right 4 bits
• Is called the Low Order nibble or LO nibble

The left nibble (Image-2)

• made of the left 4 bits
• Is called the High Order nibble or HI nibble

Using the binary system

• you can represent the byte using a combination of 0s and 1s (B-1)

(B-1) When all bits have a value of 0

• The byte is represented as 00000000

(B-1) When all bits have a value of 1

• The byte is represented as 11111111

When the number grows very large

• It becomes difficult to read. Therefore, we will represent bits in groups of four (B-2)

(B-2) Instead of writing 00000000

• We will write it as  0000 0000

Create combinations of bits using the boxes as we did for the nibble

• 2⁸, which is 256.
• There are 256 possible combinations.

Another way to find it out is by using the base 2 technique:

• 2⁷ + 2⁶ + 2⁵ + 2⁴ + 2³ + 2² + 2¹ + 2⁰
  = 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1
  = 255
• Therefore, the maximum decimal value you can store in a byte is 255

Remember that the byte with all bits having a value of 0

• Has its value set to 0
• Since this byte also holds a valid value, the number of combinations = 255 + 1 = 256

When a byte is completely represented with 0s

• It provides the minimum value it can hold
• This is 0000 0000, which is also 0

When all bits have a value of 1

• Which is 1111 1111, a byte holds its maximum value that we calculated as 255 in the decimal system
• As done with the nibble, we get the following table (Image-3):

(Image-3)

The minimum storage area offered by the (Intel) computer

• Is the byte

As you know already

• A byte is a group of 8 consecutive bits

The amount of memory space offered by a byte

• Can be used to store just a single symbol, such as those you see on your keyboard

These symbols, also called characters, have been organized

• The American Standard Code for Information Exchange (ASCII) in a set list
• But, ASCII uses only 128 decimal numbers (based on a 7-bit format) to represent symbols counted from 0 to 127
• To compensate for the remaining 1 bit, IBM used it to organize special characters, foreign language characters, mathematical symbols, small graphics, etc
• Each one of these characters has a decimal, a hexadecimal, and a binary equivalents

Each one of the characters you see on your keyboard

• Is represented as a numeric value, but whether it appears as a number, a letter, or a symbol, each one of these is considered a character

To display any character on your screen

• you can use the cout << operator and include the character between single-quotes, as (A-1)

Example of (A-1)

#include <iostream>
 
using namespace std;
 
int main()
{
 
     cout << 'a';
 
     return 0;
 
}

Nibble

• Is represented by a group of 4 bits = 1/2 byte
• This is also a system that the computer uses to count bits internally

The first bit, on the right side of the nibble

• Is called the Low Order bit or LO bit
• This is also called the least significant bit
• The bit on the right side is counted as bit 0

The last bit, on the left side of the nibble

• Is called the High Order bit or HI bit
• It is also called the most significant bit
• The bit on the left side is counted as bit 3

The other bits

• Are called by their positions: bit 1 and bit 2

When a box is empty

• It receives a value of 0
• Otherwise, it has a value of 1

(Image-2) On a group of four consecutive bits, we can have the following combinations:

 The (Image-2) produces the following binary combinations:

• 0000, 0001, 0010, 0011, 0100, 0101, 0110, 0111, 1000, 1001, 1010, 1011, 1100, 1101, 1110, 1111 = 16 combinations
• When using the decimal system, these combinations can be represented as 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, and 15

You will encounter a number that is less than four bits

• (B-1) Such as 10 or 01 or 101

How do you reconcile such a number to a nibble?

• (B-1) The technique used to complete and fill out the nibble consists of displaying 0 for each non-represented bit

Example of (B-1)

• The binary number 10 will be the same as 0010
• The number 01 is the same as 0001
• The number 101 is the same as 0101

This technique is valuable and allows you to always identify

• A binary number as a divider of 4

When all bits of a nibble are 0

• You have the lowest value you can get, which is 0000
• Any of the other combinations has at least one 0 bit
• The lowest value, also considered the minimum value, can be represented in the decimal system as 0

When all bits are 1

• This provides the highest value possible for a nibble
• The highest value, also considered the maximum, can be expressed in decimal value as 2⁴ (2 represents the fact that there are two possible states: 0 and 1; 4 represents the fact that there are four possible combinations), which is 16. This produces 16 because 2⁴ = 16

The computer recognizes

• The hexadecimal representation of bits

(Image-2) We can represent each 4-bit of the sixteen combinations using the decimal, hexadecimal, and binary systems as follows: 

When looking at a binary value represented by 4 bits

• You can get its decimal or hexadecimal values by referring to the table (Image-2)

A nibble, which is a group of four consecutive bits

• Has a minimum and maximum values on each system as follows (Image-3):
• Although the C++ compiler recognizes a group of four consecutive bits
• You cannot store any variable in a nibble
• You can, however, manipulate the bits of a nibble

(Image-3)