What it Looks Like to the User The program will loop, asking the user for a bet amount from 0 to 50 (assume dollars, you can use ints or longs ). If...

class method definition(s)

After writing this class, test it using a simple main() which instantiates an object, mutates the members, displays the object, etc.  Don't turn this test in.  It's part of your development cycle.

The Global Scope Method Specs

int getBet()

This prompts the user for input and returns the bet amount as a functional return.  It should vet the amount before it returns and insist on a legal bet (0< bet < 50) until it gets one from the user.  This method loops.  If any other method is used to test for an illegal value or output an error message based on an illegal value, there will be a 4 point penalty.  getBet() must return the legal value to the client and not take any other action besides getting the legal amount

TripleString pull()

This method instantiates and returns a TripleString object to the client.   The data of the TripleString object has to be filled with three randomly chosen strings according to the probabilities described in the "Understand the Application" section above. For example, it might return a TripleStringobject that contains the three strings ["cherries",  "BAR" , "space"]. 

The way it determines and loads the three strings is by using another global scope helper method, described, next, randString().  So this method,pull() will call the next method randString() three times to get the three strings that will be stored into the TripleString object.  Once that's done,pull() just returns the TripleString object to the client and its job is done.

string randString()

This helper method does a little work -- yet is still quite short.  It produces and returns a single random string based on the required probabilities.  It does this by calling the C++  rand() function and using the return result of that function as a means of deciding which of the four possible strings to return.  Take this in stages.  rand() returns an int between 0 and RAND_MAX.  One idea (but not the only one) is to turn that into an int  between 1 and 1000 using techniques from five weeks ago.  Then, decide which of those numbers should trigger a "7", which should trigger a "cherries", etc. based on the desired probabilities.  Since a "Bar" should happen 40% the time, which numbers would you want to trigger a "Bar"?  Since a "cherries" should happen 30% of the time, which numbers would trigger a "cherries"?  So you see, this is a very simple -- and even short -- function, even though it has to be designed carefully.  Common sense will go a long way here.

int getPayMultiplier (TripleString thePull)

After main() gets a TripleString object from pull() (which I will call thePull), it needs to know what the payout will be.  That's the job of this function, getPayMultiplier(), which takes the TripleString result from pullString() (thePull) as a parameter, and inspects it to determine what its pay multiplier should be:  5?  15?  100?  0?   It does this by looking at the three strings inside the passed-in TripleString object and using if statements to determine and return the right value.  For example, if all three of the strings are "cherries", which is easily checked using an if statement, then this method returns a pay multiplier of 30.  You can use logic like this to create a sequence of if or else if statements that will give you the desired multiplier.   However you do it, the method will return one of the values;  0, 5, 15, 30, 50 or 100.

void display (TripleString thePull, int winnings )

This method takes the winnings (a dollar amount) and thePull as parameters and displays the three strings inside thePull along with "  sorry - you lost " or "congrats, you won $X."

main()'s Workflow

You can debug each of the above methods individually using a test main() that consists of a statement or two.  That way you will make sure each component works before trying to write the final main() client. 

main() will be a loop controlled by value returned from getBet().  As long as that value is non-zero, we keep playing.

Each time through the loop, we have to call pull() to get the pullString as a return value. Then we need to pass that to getPayMultiplier() to find the multiplier.  We then compute the winnings based on the previous information, and finally we display it all using display().  That's all that each loop pass does.  So main() is quite neat and clean.

Input Errors

The only place the user can make an input error is in getBet(), so that's the method that deals with such errors.  Don't worry about non-numbers.  Assume that a number was entered.  But do test for range and only return to main after you have a valid range. getBet() may not decide about ending the program.  That's up tomain().

Test Run Requirements:

Submit one run that lasts a minimum of 40 pulls, but possibly more (continue reading).   At least once enter an illegal amount to make sure that your program handles it correctly.  Also, make sure your one run contains both a win of cherries  cherries  cherries  and a win of  BAR  BAR  BAR  This may take many runs, but should be accomplished in less than two minutes if your program is written correctly.

General Requirements

Communicate all values as parameters or return values, not through globals. The meaning of these terms and examples are contained in the module reading.

Between your source and your run, report which pull groups that resulted in all cherries and which pulls resulted in all BARs (e.g., "pull groups #3 and #5 resulted in all cherries and pull group #62 resulted in all BARs."  You can type this out in your text file manually after you have pasted the source and run in their correct places.

Also, I will emphasize that in keeping with the separation of I/O and computation, we would not have any method other than display() output results to the screen, and display() is called from main(), not from any other method. Similarly, getBet() is the only method that does input.  The other methods do no input, no output and do not call any methods that do input or output.  Let's keep that idea fresh.

A sample run is given at the bottom of this page.