(Latest Revision: Fri Nov 30 20:34:45 PST 2012 )
hints.txt
hints.txt
/* ******************************************** */
/* GETDATA */
/* ******************************************** */
/*
The purpose of function getData is to
+ read from the input file whose name is stored in: fname,
+ copy the values in the file into the array called: data, and
+ set the parameter numSlotsUsed equal to the number of
items copied into the array.
(Function getData copies the first item in the file, if one
exists, into data[0], copies the second item into data[1], and
so on.)
Function getData handles the following exceptional situations:
+ input file cannot be opened,
+ input file is empty, and
+ input file contains more elements than the value of arraySize.
In those situations, function getData prints an error message and
terminates execution of the program (exits).
HINTS
What code do we need to implement function getData?
Declare an input stream. There's a filename stored in the char array
fname. Connect the stream to the file. (in the code, include an
error-check for failure to open the file) (See example in
Notes/Programs+Files/01_read_ints.cpp)
Declare an int index variable for keeping track of which array slot gets
the next value from the file. Also declare another int variable to use as
the 'buffer'. Each time the program reads an integer from the file, it
will copy it (first) into the buffer.
Suppose that the name of the input file stream is f_in.
Then a code like
int nextDatum ;
while (f_in >> nextDatum) ;
would read through the file to the end. Something like this code:
int nextDatum ;
while (f_in >> nextDatum) cout << nextDatum << endl ;
would read through the file AND write each of the values read from the
file to the screen.
If you want the code to put each element of the file into an array as it
reads them, and if the name of the array happens to be my_array, then you
could write the code like this:
int nextDatum ;
int arrayIndex = 0 ;
while (f_in >> nextDatum)
{
my_array[arrayIndex] = nextDatum ;
arrayIndex++ ;
}
However that way of putting numbers into the array would cause a problem
if the file happens to contain more integers than there are slots in the
array. The code above would continue to read through the entire (too
big) file, and (this is the bad part) try to put integers into
non-existent array locations - locations with indexes greater than the
maximum array index. That could cause other variables in the program to
be overwritten with values intended for the array, which could lead to
incorrect behavior of the program
However if we modified the first line in the loop body, so that line is
executed only if the arrayIndex is less than the size of the array, then
the code will not try to put data in non-existent array locations, but it
will still read to the end of the file and count the number of integers
in the file. (Notice that arrayIndex will equal the number of integers
in the file after the loop finishes executing.)
Once the function has a variable equal to the number of items in the
file, it can execute some if-else statements that cause the program to
exit if the file is empty, or if the file contains too many items. On
the other hand, if the number of items in the file is OK, then the
function could use this variable to give the parameter numSlotsUsed the
value it is supposed to have.
*/
void getData (int data[ ], const char fname[ ],
int arraySize, int & numSlotsUsed)
{
}
/* ******************************************** */
/* SHOWDATA */
/* ******************************************** */
/*
The purpose of function showData is to print some text to the screen,
followed by the values of array items data[0] through
data[numSlotUsed-1]. Function showData prints array values in a field
width of 3. It prints ten values to a line, except it may print fewer
values on the last line. Function showData prints the values as a
comma-separated list. In particular, function showData prints a comma
right after each value, except the last one. It prints a period right
after the last value. Between every pair of successive items on a
line, it prints a blank space right after the comma.
See the file terminalSession.html for examples illustrating the
remaining rules for formatting the output of function showData.
HINTS
On page 377 of the text, lines 21-22 are an example of outputting the
values in an array to the screen.
There's an example of code that writes a comma separated list of
numbers here:
http://www.cs.csustan.edu/~john/Classes/CS1500/LabDir/Lab04/sampLoop4.cpp.html
You can use the setw() manipulator to write numbers right justified in
a 3-character field. Read about it on page 325 of your text book.
Concerning the problem of printing 10 numbers per line, you can test
your loop counter % 10 to decide whether to output an endl or newline
character.
*/
void showData (int data[ ], int numSlotsUsed)
{
}
/* ******************************************** */
/* FINDMIN */
/* ******************************************** */
/*
The purpose of function findMin is to set parameter minValue equal to
the minimum of the values in the data array between index positions 0
and numSlotsUsed-1 (inclusive), and also to set parameter minPos equal
to the smallest array index between 0 and numSlotsUsed-1 such that
data[minPos] is equal to the minimum value.
HINTS
Look on page 414, on lines 58-65 of the program code, to see an example
of how to find the minimum of an array of numbers. The "start_index"
for findMin should just be 0.
*/
void findMin (int data[ ], int & minValue, int & minPos, int numSlotsUsed )
{
}
/* ******************************************** */
/* FINDMAX */
/* ******************************************** */
/*
The purpose of function findMax is to set parameter maxValue equal to
the maximum of the values in the data array between index positions 0
and numSlotsUsed-1 (inclusive), and also to set parameter maxPos equal
to the smallest array index between 0 and numSlotsUsed-1 such that
data[maxPos] is equal to the maximum value.
HINTS
Look on page 414, on lines 58-65 of the program code, to see an example
of how to find the minimum of an array of numbers. The job of finding
the maximum is very similar. The "start_index" for findMax should just
be 0.
*/
void findMax (int data[ ], int & maxValue, int & maxPos, int numSlotsUsed )
{
}
/* ******************************************** */
/* AVERAGE */
/* ******************************************** */
/*
The purpose of function average is return the average of the values
data[0] through data[numSlotsUsed-1]. The average is the sum of
data[0] through data[numSlotsUsed-1], divided by numSlotsUsed.
HINTS
On page 407 of the text, there is an example (lines 46-52) of
function code that computes the average of the values in an array.
*/
double average (int data[ ], int numSlotsUsed )
{
}
/* ******************************************** */
/* STNDRDDEV */
/* ******************************************** */
/*
The purpose of function stndrdDev is to return the population
standard deviation of the values data[0] through
data[numSlotsUsed-1]. To see how to calculate the population
standard deviation, consider terms of this form:
( data[k] - average ).
The parameter called average is assumed to be the average of the
values data[0] through data[numSlotsUsed-1]. If we sum the
squares of each of the terms shown above, then divide the
result by numSlotsUsed, and finally take the square root of the
result, that final value is the population standard deviation.
See this web page for a formula written out in mathematical
notation and then explained one small step at a time:
http://www.mathsisfun.com/data/standard-deviation-formulas.html
(However of course you must adjust for the fact that N items in
a C++ array are numbered starting at 0 and ending with N-1,
whereas in the explanation on the web page the authors assumed
that there are N items numbered starting with item 1 and ending
with item N.)
HINTS
The code for computing the standard deviation can be a lot like the
code for computing the average. One computes the square root of an
average of some terms. Each individual term is a "square difference."
The difference is the difference between the array value and the
average -- in other words you average all terms of the form:
(data[k]-average)*(data[k]-average)
You average all terms like that, where the index k ranges from 0 to
numSlotsUsed-1.
*/
double stndrdDev (double average, int data[ ], int numSlotsUsed )
{
}