C++ Primer Plus

The first evaluates to 90 / 2 and then to 45, whereas the second evaluates to 5 × 9 and then to 45. Both give the same answer, but the first method produces a larger intermediate value (90) than does the second. The more factors you have, the bigger the difference gets. For large numbers, this strategy of alternating multiplication with division can keep the calculation from overflowing the maximum possible floating-point value.

Listing 7.4 incorporates this formula into a probability() function. Because the number of picks and the total number of choices should be positive values, the program uses the unsigned int type (unsigned, for short) for those quantities. Multiplying several integers can produce pretty large results, so lotto.cpp uses the long double type for the function’s return value. Also terms such as 49 / 6 produce a truncation error for integer types.

Note

Some C++ implementations don’t support type long double. If your implementation falls into that category, try ordinary double instead.

Listing 7.4. lotto.cpp

// lotto.cpp -- probability of winning

#include

// Note: some implementations require double instead of long double

long double probability(unsigned numbers, unsigned picks);

int main()

{

    using namespace std;

    double total, choices;

    cout << "Enter the total number of choices on the game card and\n"

            "the number of picks allowed:\n";

    while ((cin >> total >> choices) && choices <= total)

    {

        cout << "You have one chance in ";

        cout << probability(total, choices);      // compute the odds

        cout << " of winning.\n";

        cout << "Next two numbers (q to quit): ";

    }

    cout << "bye\n";

    return 0;

}

// the following function calculates the probability of picking picks

// numbers correctly from numbers choices

long double probability(unsigned numbers, unsigned picks)

{

    long double result = 1.0;  // here come some local variables

    long double n;

    unsigned p;

    for (n = numbers, p = picks; p > 0; n--, p--)

        result = result * n / p ;

    return result;

}

Here’s a sample run of the program in Listing 7.4:

Enter the total number of choices on the game card and

the number of picks allowed:

49 6

You have one chance in 1.39838e+007 of winning.

Next two numbers (q to quit): 51 6

You have one chance in 1.80095e+007 of winning.

Next two numbers (q to quit): 38 6

You have one chance in 2.76068e+006 of winning.

Next two numbers (q to quit): q

bye

Notice that increasing the number of choices on the game card greatly increases the odds against winning.

Program Notes

The probability() function in Listing 7.4 illustrates two kinds of local variables you can have in a function. First, there are the formal parameters (numbers and picks), which are declared in the function header before the opening brace. Then come the other local variables (result, n, and p). They are declared in between the braces bounding the function definition. The main difference between the formal parameters and the other local variables is that the formal parameters get their values from the function that calls probability(), whereas the other variables get values from within the function.

Functions and Arrays

So far the sample functions in this book have been simple, using only the basic types for arguments and return values. But functions can be the key to handling more involved types, such as arrays and structures. Let’s take a look now at how arrays and functions get along with each other.

Suppose you use an array to keep track of how many cookies each person has eaten at a family picnic. (Each array index corresponds to a person, and the value of the element corresponds to the number of cookies that person has eaten.) Now you want the total. That’s easy to find; you just use a loop to add all the array elements. But adding array elements is such a common task that it makes sense to design a function to do the job. Then you won’t have to write a new loop every time you have to sum an array.

Let’s consider what the function interface involves. Because the function calculates a sum, it should return the answer. If you keep your cookies intact, you can use a function with a type int return value. So that the function knows what array to sum, you want to pass the array name as an argument. And to make the function general so that it is not restricted to an array of a particular size, you pass the size of the array. The only new ingredient here is that you have to declare that one of the formal arguments is an array name. Let’s see what that and the rest of the function header look like:

int sum_arr(int arr[], int n) // arr = array name, n = size