COP3503 Lab 8 – Numeric Conversion Solution

Overview
In this assignment you are going to read common color names and their corresponding numeric values from a group of files. One small issue: the numbers are in the wrong format. They are stored in integers, while typically color values are represented in one of two ways--either in hexadecimal form, or as their 3 separate color channels. For example, the color red might be represented like this:
0xFF0000 as hexadecimal
Red: 255, Green: 0, Blue: 0 as unsigned characters, or
Red: 1.0f, Green: 0.0f, Blue: 0.0f as floats
The integer representation of that color would be 16711680—this number is, at face value, useless. However, breaking that integer into multiple, individual pieces is often done. In this assignment, you are going to convert this not-so-helpful integer into a helpful hex value and RGB value. For more general information on color codes:
https://htmlcolorcodes.com/ https://www.w3schools.com/colors/colors_names.asp
Description
The six files to load are called colors1.txt, colors2.txt, etc up to colors6.txt. Each file contains a list of colors with their name and integer representation of the color. You are to write a small program that loads one or more of these files, converts the values to hex/RGB values, and stores the list of colors in a std::map object.
The way to store/retrieve these values is by bit-shifting.
Imagine a single byte (i.e. a signed or unsigned character), made up of 8 bits:
The number 12 in binary form: 0 0 0 0 1 1 0 0
The number 255 in binary: 1 1 1 1 1 1 1 1
If you wanted to store these two separate values in one 2-byte short (12 first, then 255), the bytes for that short would look like: 0 0 0 0 1 1 0 0 1 1 1 1 1 1 1 1. Its decimal value would be 3,327 which, has no obvious connection to either of the two values we’re storing. All of memory is like this, but fortunately for programmers we can deal with memory one variable at a time.
If we took a short, and initialized it to 12, its bytes would be 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0. Look at all that empty space on the left! So much room, you can store all kinds of things in there! (All kinds of things, as long as those things are bits.) If you want to store the 12 “on the left” you would left-shift the value. Each time you shift a value, its bits move over as many bits as you specify.
short value = 12;
0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 □ 12
value = value << 1; // Left-shift by 1
-------0 0 0 0 0 0 0 --------0 0 0 0 1 1 0 0 -0 □ 24
value = value >> 3; // Right-shift by 3
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 □ 3
Right-shifting again would “push” the right-most bit off, resulting in a value of 1

One thing you might notice is that bit-shifting multiplies or divides the value—left-shifting multiplies, while right-shifting divides. The amount of the modification is 2 to power of the number of bits by which you shifted. So left-shifting by 3 multiplies by 23, while right-shifting by 2 would divide by 22 .
If you wanted to store the value of 12 in the “high byte” you would need to move the value over one byte, or 8 bits.
short value = 12 << 8;
--------0 0 0 0 1 1 0 0 --------0 0 0 0 0 0 0 0 D 3072
Store the value in the “high” byte 12 << 8 == 12 * 28 == 3,072
value += 255
--------0 0 0 0 1 1 0 0 --------1 1 1 1 1 1 1 1 D 3327
Storing 2 unsigned char values in a single variable!

For this assignment, you will be employing this concept to retrieve 3 unsigned char values from a single integer value. The integer is a 32-bit variable, and you will be retrieving values from bits 0-7 (the blue value), bits 8-15 (the green value), and bits 16-23 (the red value). Visually this would look like the following:


In addition to storing values, you will need to retrieve those byte-values from the variable. This can be done by shifting and comparing to some known value, using the bitwise & operator. The & operator will compare two values, and every bit that is turned on (set to 1) in BOTH values will be present in the final result. For example:


Retrieving the green value would be a similar process, by shifting the original value 8 bits, and the blue value wouldn’t need to be shifted at all before the & comparison. After you’ve shifted and ANDed, you store the value in an unsigned char, and that’s it! If you wanted to put the value back in, you could start at zero, and then add the red value left-shifted by 16 bits, the green value left-shifted 8 bits, and then the blue value. If you were using an alpha value, that would be shifted by 24 bits.
Hexadecimal Conversion
After converting your colors to RGB, you will have to store it in a string representing the hexadecimal equivalent. Color values are often represented as hexadecimal numbers, with 2 letters each for the red, green, and blue values. Color values in character form range from 0-255, which can be stored in two hexadecimal digits, 0-FF. The color green would be 0x00FF00, blue would be 0x0000FF, a dark purple color with a value of 93, 0, 106 would be #5D006A.
Hexadecimal is base 16, which means each digit has a value from 0-15, or 0-9, then A is 10, B is 11, C, D, E, and F is 15. The first digit contributes its value to the total value of the number, the second digit contributes 161 times the value of the digit to the total of the number, and so on. For example, a value of F3 is (15 ∗ 161) + (3 ∗ 160), or 243.
Example
Because we’re dealing with numbers with a maximum value of 255 (and thus just 2 hex digits), the process for this is pretty straightforward:
Take your number and divide it by 16. The result is the number you want to convert to the first digit in the hex number. If the value is 0-9, then use that number as-is. If the number is 10-15, you need to convert it to the letters A-F.
Decimal 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Hex 0 1 2 3 4 5 6 7 8 9 A B C D E F
I I I I I I I

After that, you want to get the remainder of the original division to use as the second digit. For that, you can use the modulus operator. Take the result of the modulus operation and convert that number to a hex digit as well.
Take the number 243 (which should be F3 in hex):
243 / 16 = 15, with a remainder of 3 (16 * 15 = 240)
15 in hex is F
243 % 16 = 3, the remainder
3 in hex is just 3
If you were storing that in a std::string variable, string[0] would be the character 'F', and string[1] would be '3'. You could use the .resize() function to allocate space for 2 characters in the string, or you could assign it a default string of "00" and overwrite the two characters afterward—the std::string class has the subscript operator overloaded to access/modify individual elements of the string.
Color Class
The Color class you will write for this assignment is pretty simple. You will need to store the name and hex value of the color as std::strings, and the RGB values as unsigned characters. You should have the following functions in your class. Any other supporting functions/variables you want to create are up to you.

/* Insert any other functions/data members that you want */
Searching
After you have loaded and stored the colors, there will be an option to print everything or search for a single color by its name (the key in the std::map object). If the entered string is found in the map (using the find() function, refer to previous slides/lectures on searching for key/values in a std::map), print out the Color. If not, simply print out that their entry was not found. For example, if the user searched for the color “MintGreen” and it wasn’t found, print out:
MintGreen not found!

Example Output
The output for files 1 and 2 are given so you can test your code against different sets of data. Each other file follows exactly the same format, though of the number of colors in each are different.