C++ How to Program, Eighth Edition > Classes: A Deeper Look, Part 2 > Exercises - Pg. : Safari Books Online

Table of Contents

Download Safari Books Online apps: Apple iOS | Android

Entire Site

Safari Books Online is a digital library providing on-demand subscription access to thousands of learning resources.

This Book

C++ How to Program, Eighth Edition

C++ How to Program, Eighth Edition

Search

Contents

Table of Contents

Deitel® Series Page

Ch. 1. Introduction to Computers and C++

Ch. 2. Introduction to C++ Programming

Ch. 3. Introduction to Classes, Objects and Strings

Ch. 4. Control Statements: Part 1

Ch. 5. Control Statements: Part 2

Ch. 6. Functions and an Introduction to Recursion

Ch. 7. Arrays and Vectors

Ch. 8. Pointers

Ch. 9. Classes: A Deeper Look, Part 1

Ch. 10. Classes: A Deeper Look, Part 2

const (Constant) Objects and const Member Functions

Composition: Objects as Members of Classes

friend Functions and friend Classes

Using the this Pointer

static Class Members

Self-Review Exercises

Answers to Self-Review Exercises

Making a Difference

Ch. 11. Operator Overloading; Class string

Ch. 12. Object-Oriented Programming: Inheritance

Ch. 13. Object-Oriented Programming: Polymorphism

Ch. 14. Templates

Ch. 15. Stream Input/Output

Ch. 16. Exception Handling: A Deeper Look

Ch. 17. File Processing

Ch. 18. Class string and String Stream Processing

Ch. 19. Searching and Sorting

Ch. 20. Custom Templatized Data Structures

Ch. 21. Bits, Characters, C Strings and structs

Ch. 22. Standard Template Library (STL)

Ch. 23. Boost Libraries, Technical Report 1 and C++0x

Ch. 24. Other Topics

Chapters on the Web

Appx. A. Operator Precedence and Associativity

Appx. B. ASCII Character Set

Appx. C. Fundamental Types

Appx. D. Number Systems

Appx. E. Preprocessor

Appendices on the Web

Ch. 25. ATM Case Study, Part 1: Object-Oriented Design with the UML

Ch. 26. ATM Case Study, Part 2: Implementing an Object-Oriented Design

Appx. F. C Legacy Code Topics

Appx. G. UML 2: Additional Diagram Types

Appx. H. Using the Visual Studio Debugger

Appx. I. Using the GNU C++ Debugger

Inside Front Cover

Inside Back Cover

URL

Help

Exercises

10.3	(Friendship) Explain the notion of friendship. Explain the negative aspects of friendship as described in the text.
10.4	(Constructor Overloading) Can a correct `Time` class definition include both of the following constructors? If not, explain why not. Time( int h = 0, int m = 0, int s = 0 ); Time();
10.5	(Constructors and Destructors) What happens when a return type, even `void`, is specified for a constructor or destructor?
10.6	(`Date` Class Modification) Modify class `Date` in Fig. 10.8 to have the following capabilities: Output the date in multiple formats such as DDD YYYY MM/DD/YY June 14, 1992 Use overloaded constructors to create `Date` objects initialized with dates of the formats in part (a). Create a `Date` constructor that reads the system date using the standard library functions of the `<ctime>` header and sets the `Date` members. (See your compiler’s reference documentation or www.cplusplus.com/ref/ctime/index.html for information on the functions in header `<ctime>`.) In Chapter 11, we’ll be able to create operators for testing the equality of two dates and for comparing dates to determine whether one date is prior to, or after, another.
10.7	(`SavingsAccount` Class) Create a `SavingsAccount` class. Use a `static` data member `annualInterestRate` to store the annual interest rate for each of the savers. Each member of the class contains a `private` data member `savingsBalance` indicating the amount the saver currently has on deposit. Provide member function `calculateMonthlyInterest` that calculates the monthly interest by multiplying the `balance` by `annualInterestRate` divided by 12; this interest should be added to `savingsBalance`. Provide a `static` member function `modifyInterestRate` that sets the `static annualInterestRate` to a new value. Write a driver program to test class `SavingsAccount`. Instantiate two different objects of class `SavingsAccount`, `saver1` and `saver2`, with balances of $2000.00 and $3000.00, respectively. Set the `annualInterestRate` to 3 percent. Then calculate the monthly interest and print the new balances for each of the savers. Then set the `annualInterestRate` to 4 percent, calculate the next month’s interest and print the new balances for each of the savers.
10.8	(`IntegerSet` Class) Create class `IntegerSet` for which each object can hold integers in the range 0 through 100. Represent the set internally as a `vector` of `bool` values. Element `a[i]` is `true` if integer i is in the set. Element `a[j]` is `false` if integer j is not in the set. The default constructor initializes a set to the so-called “empty set,” i.e., a set for which all elements contain `false`. Provide member functions for the common set operations. For example, provide a `unionOfSets` member function that creates a third set that is the set-theoretic union of two existing sets (i.e., an element of the result is set to `true` if that element is `true` in either or both of the existing sets, and an element of the result is set to `false` if that element is `false` in each of the existing sets). Provide an `intersectionOfSets` member function which creates a third set which is the set-theoretic intersection of two existing sets (i.e., an element of the result is set to `false` if that element is `false` in either or both of the existing sets, and an element of the result is set to `true` if that element is `true` in each of the existing sets). Provide an `insertElement` member function that places a new integer k into a set by setting `a[k]` to `true`. Provide a `deleteElement` member function that deletes integer m by setting `a[m]` to `false`. Provide a `printSet` member function that prints a set as a list of numbers separated by spaces. Print only those elements that are present in the set (i.e., their position in the `vector` has a value of `true`). Print `---` for an empty set. Provide an `isEqualTo` member function that determines whether two sets are equal. Provide an additional constructor that receives an array of integers and the size of that array and uses the array to initialize a set object. Now write a driver program to test your `IntegerSet` class. Instantiate several `IntegerSet` objects. Test that all your member functions work properly.
10.9	(`Time` Class Modification) It would be perfectly reasonable for the `Time` class of Figs. 10.15–10.16 to represent the time internally as the number of seconds since midnight rather than the three integer values `hour`, `minute` and `second`. Clients could use the same `public` methods and get the same results. Modify the `Time` class of Fig. 10.15 to implement the time as the number of seconds since midnight and show that there is no visible change in functionality to the clients of the class. [Note: This exercise nicely demonstrates the virtues of implementation hiding.]
10.10	(Card Shuffling and Dealing) Create a program to shuffle and deal a deck of cards. The program should consist of class `Card`, class `DeckOfCards` and a driver program. Class `Card` should provide: Data members `face` and `suit` of type `int`. A constructor that receives two `int`s representing the face and suit and uses them to initialize the data members. Two `static` arrays of `string`s representing the faces and suits. A `toString` function that returns the `Card` as a `string` in the form “face `of` suit.” You can use the `+` operator to concatenate `string`s. Class `DeckOfCards` should contain: A `vector` of `Card`s named `deck` to store the `Card`s. An integer `currentCard` representing the next card to deal. A default constructor that initializes the `Card`s in the deck. The constructor should use `vector` function `push_back` to add each `Card` to the end of the `vector` after the `Card` is created and initialized. This should be done for each of the 52 `Card`s in the deck. A `shuffle` function that shuffles the `Card`s in the deck. The shuffle algorithm should iterate through the `vector` of `Card`s. For each `Card`, randomly select another `Card` in the deck and swap the two `Card`s. A `dealCard` function that returns the next `Card` object from the deck. A `moreCards` function that returns a `bool` value indicating whether there are more `Card`s to deal. The driver program should create a `DeckOfCards` object, shuffle the cards, then deal the 52 cards.
10.11	(Card Shuffling and Dealing) Modify the program you developed in Exercise 10.10 so that it deals a five-card poker hand. Then write functions to accomplish each of the following: Determine whether the hand contains a pair. Determine whether the hand contains two pairs. Determine whether the hand contains three of a kind (e.g., three jacks). Determine whether the hand contains four of a kind (e.g., four aces). Determine whether the hand contains a flush (i.e., all five cards of the same suit). Determine whether the hand contains a straight (i.e., five cards of consecutive face values).

Card Shuffling and Dealing Projects

10.12	(Card Shuffling and Dealing) Use the functions from Exercise 10.11 to write a program that deals two five-card poker hands, evaluates each hand and determines which is the better hand.
10.13	(Card Shuffling and Dealing) Modify the program you developed in Exercise 10.12 so that it can simulate the dealer. The dealer’s five-card hand is dealt “face down” so the player cannot see it. The program should then evaluate the dealer’s hand, and, based on the quality of the hand, the dealer should draw one, two or three more cards to replace the corresponding number of unneeded cards in the original hand. The program should then reevaluate the dealer’s hand.
10.14	(Card Shuffling and Dealing) Modify the program you developed in Exercise 10.13 so that it handles the dealer’s hand, but the player is allowed to decide which cards of the player’s hand to replace. The program should then evaluate both hands and determine who wins. Now use this new program to play 20 games against the computer. Who wins more games, you or the computer? Have one of your friends play 20 games against the computer. Who wins more games? Based on the results of these games, make appropriate modifications to refine your poker-playing program. Play 20 more games. Does your modified program play a better game?

You are currently reading a PREVIEW of this book.

Get instant access to over
$1 million worth of books and videos.

Start a Free Trial