Wrap-Up

Provide the definition for each of the following structures:

1. Structure Inventory, containing character array partName[ 30 ], integer partNumber, floating-point price, integer stock and integer reorder.
2. A structure called Address that contains character arrays streetAddress[ 25 ], city[ 20 ], state[ 3 ] and zipCode[ 6 ].
3. Structure Student, containing arrays firstName[ 15 ] and lastName[ 15 ] and variable homeAddress of type struct Address from part (b).
4. Structure Test, containing 16 bit fields with widths of 1 bit. The names of the bit fields are the letters a to p.

Consider the following structure definitions and variable declarations:

struct Customer { char lastName[ 15 ]; char firstName[ 15 ]; int customerNumber; struct { char phoneNumber[ 11 ]; char address[ 50 ]; char city[ 15 ]; char state[ 3 ]; char zipCode[ 6 ]; } personal; } customerRecord, *customerPtr; customerPtr = &customerRecord;  

Write a separate expression that accesses the structure members in each of the following parts:

1. Member lastName of structure customerRecord.
2. Member lastName of the structure pointed to by customerPtr.
3. Member firstName of structure customerRecord.
4. Member firstName of the structure pointed to by customerPtr.
5. Member customerNumber of structure customerRecord.
6. Member customerNumber of the structure pointed to by customerPtr.
7. Member phoneNumber of member personal of structure customerRecord.
8. Member phoneNumber of member personal of the structure pointed to by customerPtr.
9. Member address of member personal of structure customerRecord.
10. Member address of member personal of the structure pointed to by customerPtr.
11. Member city of member personal of structure customerRecord.
12. Member city of member personal of the structure pointed to by customerPtr.
13. Member state of member personal of structure customerRecord.
14. Member state of member personal of the structure pointed to by customerPtr.
15. Member zipCode of member personal of structure customerRecord.
16. Member zipCode of member personal of the structure pointed to by customerPtr.

Modify the program of Fig. 22.14 to shuffle the cards using a high-performance shuffle, as shown in Fig. 22.3. Print the resulting deck in two-column format, as in Fig. 22.4. Precede each card with its color.

Write a program that right-shifts an integer variable 4 bits. The program should print the integer in bits before and after the shift operation. Does your system place zeros or ones in the vacated bits?

Left-shifting an unsigned integer by 1 bit is equivalent to multiplying the value by 2. Write function power2 that takes two integer arguments, number and pow, and calculates

number * 2pow  

Use a shift operator to calculate the result. The program should print the values as integers and as bits.

The left-shift operator can be used to pack two character values into a two-byte unsigned integer variable. Write a program that inputs two characters from the keyboard and passes them to function packCharacters. To pack two characters into an unsigned integer variable, assign the first character to the unsigned variable, shift the unsigned variable left by 8 bit positions and combine the unsigned variable with the second character using the bitwise inclusive-OR operator. The program should output the characters in their bit format before and after they are packed into the unsigned integer to prove that they are in fact packed correctly in the unsigned variable.

Using the right-shift operator, the bitwise AND operator and a mask, write function unpackCharacters that takes the unsigned integer from Exercise 22.11 and unpacks it into two characters. To unpack two characters from an unsigned two-byte integer, combine the unsigned integer with the mask 65280 (11111111 00000000) and right-shift the result 8 bits. Assign the resulting value to a char variable. Then, combine the unsigned integer with the mask 255 (00000000 11111111). Assign the result to another char variable. The program should print the unsigned integer in bits before it is unpacked, then print the characters in bits to confirm that they were unpacked correctly.

If your system uses four-byte integers, rewrite the program of Exercise 22.11 to pack four characters.

If your system uses four-byte integers, rewrite the function unpackCharacters of Exercise 22.12 to unpack four characters. Create the masks you need to unpack the 4 characters by left-shifting the value 255 in the mask variable by 8 bits 0, 1, 2 or 3 times (depending on the byte you are unpacking).

Write a program that reverses the order of the bits in an unsigned integer value. The program should input the value from the user and call function reverseBits to print the bits in reverse order. Print the value in bits both before and after the bits are reversed to confirm that the bits are reversed properly.

Write a program that demonstrates passing an array by value. [Hint: Use a struct.] Prove that a copy was passed by modifying the array copy in the called function.

Write a program that inputs a character from the keyboard and tests the character with each function in the character-handling library. Print the value returned by each function.

The following program uses function multiple to determine whether the integer entered from the keyboard is a multiple of some integer X. Examine function multiple, then determine the value of X.

What does the following program do?

Write a program that inputs a line of text with istream member function getline (as in Chapter 15) into character array s[ 100 ]. Output the line in uppercase letters and lowercase letters.

Write a program that inputs four strings that represent integers, converts the strings to integers, sums the values and prints the total of the four values. Use only the C-style string-processing techniques shown in this chapter.

Write a program that inputs four strings that represent floating-point values, converts the strings to double values, sums the values and prints the total of the four values. Use only the C-style string-processing techniques shown in this chapter.

Write a program that inputs a line of text and a search string from the keyboard. Using function strstr, locate the first occurrence of the search string in the line of text, and assign the location to variable searchPtr of type char *. If the search string is found, print the remainder of the line of text beginning with the search string. Then use strstr again to locate the next occurrence of the search string in the line of text. If a second occurrence is found, print the remainder of the line of text beginning with the second occurrence. [Hint: The second call to strstr should contain the expression searchPtr + 1 as its first argument.]

Write a program based on the program of Exercise 22.23 that inputs several lines of text and a search string, then uses function strstr to determine the total number of occurrences of the string in the lines of text. Print the result.

Write a program that inputs several lines of text and a search character and uses function strchr to determine the total number of occurrences of the character in the lines of text.

Write a program based on the program of Exercise 22.25 that inputs several lines of text and uses function strchr to determine the total number of occurrences of each letter of the alphabet in the text. Uppercase and lowercase letters should be counted together. Store the totals for each letter in an array, and print the values in tabular format after the totals have been determined.

The chart in Appendix B shows the numeric code representations for the characters in the ASCII character set. Study this chart, and then state whether each of the following is true or false:

1. The letter "A" comes before the letter "B."
2. The digit "9" comes before the digit "0."
3. The commonly used symbols for addition, subtraction, multiplication and division all come before any of the digits.
4. The digits come before the letters.
5. If a sort program sorts strings into ascending sequence, then the program will place the symbol for a right parenthesis before the symbol for a left parenthesis.

Write a program that reads a series of strings and prints only those strings beginning with the letter "b."

Write a program that reads a series of strings and prints only those strings that end with the letters "ED."

Write a program that inputs an ASCII code and prints the corresponding character. Modify this program so that it generates all possible three-digit codes in the range 000255 and attempts to print the corresponding characters. What happens when this program is run?

Using the ASCII character chart in Appendix B as a guide, write your own versions of the character-handling functions in Fig. 22.17.

Write your own versions of the functions in Fig. 22.21 for converting strings to numbers.

Write your own versions of the functions in Fig. 22.28 for searching strings.

Write your own versions of the functions in Fig. 22.35 for manipulating blocks of memory.

(Project: A Spelling Checker) Many popular word-processing software packages have builtin spell checkers. We used spell-checking capabilities in preparing this book and discovered that, no matter how careful we thought we were in writing a chapter, the software was always able to find a few more spelling errors than we were able to catch manually.

In this project, you are asked to develop your own spell-checker utility. We make suggestions to help get you started. You should then consider adding more capabilities. You might find it helpful to use a computerized dictionary as a source of words.

Why do we type so many words with incorrect spellings? In some cases, it is because we simply do not know the correct spelling, so we make a "best guess." In some cases, it is because we transpose two letters (e.g., "defualt" instead of "default"). Sometimes we double-type a letter accidentally (e.g., "hanndy" instead of "handy"). Sometimes we type a nearby key instead of the one we intended (e.g., "biryhday" instead of "birthday"). And so on.

Design and implement a spell-checker program. Your program maintains an array wordList of character strings. You can either enter these strings or obtain them from a computerized dictionary.

Your program asks a user to enter a word. The program then looks up that word in the wordList array. If the word is present in the array, your program should print "Word is spelled correctly."

If the word is not present in the array, your program should print "Word is not spelled correctly." Then your program should try to locate other words in wordList that might be the word the user intended to type. For example, you can try all possible single transpositions of adjacent letters to discover that the word "default" is a direct match to a word in wordList. Of course, this implies that your program will check all other single transpositions, such as "edfault," "dfeault," "deafult," "defalut" and "defautl." When you find a new word that matches one in wordList, print that word in a message such as "Did you mean "default?"."

Implement other tests, such as the replacing of each double letter with a single letter and any other tests you can develop to improve the value of your spell checker.