lafore_robert_objectoriented_programming_in_c

A Card Game Example

Let’s examine a different kind of example. This one uses a structure to model a playing card. The program imitates a game played by cardsharps (professional gamblers) at carnivals. The cardsharp shows you three cards, then places them face down on the table and interchanges their positions several times. If you can guess correctly where a particular card is, you win. Everything is in plain sight, yet the cardsharp switches the cards so rapidly and confusingly that the player (the mark) almost always loses track of the card and loses the game, which is, of course, played for money.

Here’s the structure the program uses to represent a playing card:

struct card

{

int number; int suit; };

This structure uses separate members to hold the number of the card and the suit. The number runs from 2 to 14, where 11, 12, 13, and 14 represent the jack, queen, king, and ace, respectively (this is the order used in poker). The suit runs from 0 to 3, where these four numbers represent clubs, diamonds, hearts, and spades.

Here’s the listing for CARDS:

//cards.cpp

//demonstrates structures using playing cards #include <iostream>

using namespace std;

4

STRUCTURES

Here’s some sample interaction with the program:

In this case the hapless mark chose the wrong card (the right answer is 2).

The program begins by defining a number of variables of type const int for the face card and suit values. (Not all these variables are used in the program; they’re included for completeness.) Next the card structure is specified. The program then defines three uninitialized variables of type card: temp, chosen, and prize. It also defines three cards—card1, card2, and card3—which it initializes to three arbitrary card values. It prints out the values of these cards for the user’s information. It then sets a card variable, prize, to one of these card values as a way of remembering it. This card is the one whose location the player will be asked to guess at the end of the game.

Next the program rearranges the cards. It swaps the first and third cards, the second and third cards, and the first and second cards. Each time it tells the user what it’s doing. (If you find the program too easy, you can add more such statements to further shuffle the cards. Flashing the statements on the screen for a limited time would also increase the challenge.)

Finally the program asks the player what position a particular card is in. It sets a card variable, chosen, to the card in this position, and then compares chosen with the prize card. If they match, it’s a win for the player; if not, it’s a loss.

Notice how easy swapping cards is.

temp = card3; card3 = card1; card1 = temp;

Although the cards represent structures, they can be moved around very naturally, thanks to the ability of the assignment operator (=) to work with structures.

4

STRUCTURES

FIGURE 4.8

Syntax of enum specifier.

An enumeration is a list of all possible values. This is unlike the specification of an int, for example, which is given in terms of a range of values. In an enum you must give a specific name to every possible value. Figure 4.9 shows the difference between an int and an enum.

Once you’ve declared the enum type days_of_week as shown, you can define variables of this type. DAYENUM has two such variables, day1 and day2, defined in the statement

days_of_week day1, day2;

(In C you must use the keyword enum before the type name, as in

enum days_of_week day1, day2;

4

STRUCTURES

The isWord variable is set to NO when the program starts. When the program encounters the first nonspace character, it sets isWord to YES to indicate that it’s in the middle of a word. It keeps this value until the next space is found, at which point it’s set back to NO. Behind the scenes, NO has the value 0 and YES has the value 1, but we avoid making use of this fact. We could have used if(isWord) instead of if(isWord == YES), and if(!isWord) instead of if(isWord == NO), but this is not good style.

Note also that we need an extra set of braces around the second if statement in the program, so that the else will match the first if.

Another approach to a yes/no situation such as that in WDCOUNT is to use a variable of type bool. This may be a little more straightforward, depending on the situation.

Organizing the Cards

Here’s our final example of enum types. Remember that in the CARDS program earlier in this chapter we defined a group of constants of type const int to represent a card’s suits.

const int clubs = 0; const int diamonds = 1; const int hearts = 2; const int spades = 3;

This sort of list is somewhat clumsy. Let’s revise the CARDS program to use enumerations instead. Here’s the listing for CARDENUM:

//cardenum.cpp

//demonstrates enumerations #include <iostream>

using namespace std;

const int jack = 11; //2 through 10 are unnamed integers const int queen = 12;

const int king = 13; const int ace = 14;

enum Suit { clubs, diamonds, hearts, spades };

////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////

int main()

{

4

STRUCTURES