for
LoopLet’s be a bit more ambitious with loops. Listing 5.4 uses a loop to calculate and store the first 16 factorials. Factorials, which are handy for computing odds, are calculated the following way. Zero factorial, written as 0!, is defined to be 1. Then, 1! is 1 * 0!, or 1. Next, 2! is 2 * 1!, or 2. Then, 3! is 3 * 2!, or 6, and so on, with the factorial of each integer being the product of that integer with the preceding factorial. (One of the late pianist-comedian Victor Borge’s best-known monologues featured phonetic punctuation, in which the exclamation mark is pronounced something like phffft pptz, with a moist accent. However, in this case, “!” is pronounced “factorial.”) The program uses one loop to calculate the values of successive factorials, storing them in an array. Then it uses a second loop to display the results. Also the program introduces the use of external declarations for values.
// formore.cpp -- more looping with for
#include <iostream>
const int ArSize = 16; // example of external declaration
int main()
{
long long factorials[ArSize];
factorials[1] = factorials[0] = 1LL;
for (int i = 2; i < ArSize; i++)
factorials[i] = i * factorials[i-1];
for (int i = 0; i < ArSize; i++)
std::cout << i << "! = " << factorials[i] << std::endl;
return 0;
}
Here is the output from the program in Listing 5.4:
0! = 1
1! = 1
2! = 2
3! = 6
4! = 24
5! = 120
6! = 720
7! = 5040
8! = 40320
9! = 362880
10! = 3628800
11! = 39916800
12! = 479001600
13! = 6227020800
14! = 87178291200
15! = 1307674368000
Factorials get big fast!
This listing uses the long long
type. If your system doesn’t have that type available, you can use double
. However, the integer format gives a nicer visual representation of how the numbers grow larger.
The program in Listing 5.4 creates an array to hold the factorial values. Element 0 is 0!, element 1 is 1!, and so on. Because the first two factorials equal 1, the program sets the first two elements of the factorials
array to 1.0. (Remember, the first element of an array has an index value of 0.) After that, the program uses a loop to set each factorial to the product of the index with the previous factorial. The loop illustrates that you can use the loop counter as a variable in the body of the loop.
The program in Listing 5.4 demonstrates how the for
loop works hand-in-hand with arrays by providing a convenient means to access each array member in turn. Also formore.cpp
uses const
to create a symbolic representation (ArSize
) for the array size. Then it uses ArSize
wherever the array size comes into play, such as in the array definition and in the limits for the loops handling the array. Now, if you wish to extend the program to, say, 20 factorials, you just have to set ArSize
to 20 in the program and recompile. By using a symbolic constant, you avoid having to change every occurrence of 16 to 20 individually.
It’s usually a good idea to define a const
value to represent the number of elements in an array. You can use the const
value in the array declaration and in all other references to the array size, such as in a for
loop.
The limit expression i < ArSize
reflects the fact that subscripts for an array with ArSize
elements run from 0
to ArSize - 1
, so the array index should stop one short of ArSize
. You could use the test i <= ArSize - 1
instead, but it looks awkward in comparison.
Note that the program declares the const int
variable ArSize
outside the body of main()
. As the end of Chapter 4, “Compound Types,” mentions, this makes ArSize
external data. The two consequences of declaring ArSize
in this fashion are that ArSize
exists for the duration of the program and that all functions in the program file can use it. In this particular case, the program has just one function, so declaring ArSize
externally has little practical effect. But multifunction programs often benefit from sharing external constants, so we’ll practice using them next.
Also this example reminds us that we can use std::
instead of a using
directive to make selected standard names available.
18.117.138.178