|
This assignment is due
by December 09, 2016 08:00am.
The Purpose
This extra credit homework allows you
to earn 20 extra credit homework points. To do so, you must demonstrate
a proficiency in classes, file input and output, pointers, and
dynamically allocating memory and arrays.
The Person Class
Write a Person class in C++, with separate person.h and person.cpp
files. Your Person class should have the following private data
members:
- first name (string)
- last name (string)
- gender (character)
- age (integer)
- height (double)
- likes monster movies (bool)
- likes cantaloupe (bool)
In addition, your Person class should have the following member
functions:
- A default constructor. You can decide what to initialize the
private data members to.
- You do not need to add getters and setters for every data member.
Instead, only add accessor functions that you actually use in your
main().
- An
input function that reads in the data members, in
the order listed above. The function should allow the user to send in
either the standard input stream or a file input stream, depending on
the user's choice.
- An
output function that writes the data members, in
the order listed above. Provide appropriate text so reading the
output makes sense. The function should allow the user to send in
either the standard output stream or a file output stream, depending
on the user's choice.
- A
validate function that tests whether a person's
data meets your criteria for a potential coding partner. You should
choose the gender (male or female), with an age between 18 and 40
(inclusive), the height under 7.5 feet (else the 'person' is likely a
monster), and someone who likes to eat cantaloupe while watching
monster movies.
NOTE: you can assume the file you are reading in is correct, e.g., only
'M' or 'F' is given for gender.
You may want to consider NotePad or
WordPad on your computer to write your code for your Person class. Once
you feel good about what you've written, copy the code into Visual
Studio. Doing this will help you see where you might make mistakes on
upcoming exams. (No, pointers and dynamic memory will not be on any
exam, but classes will!)
Your
main()
Requirements:
Before we allocate space for our
persons, we need to find out how many we need. First, we'll read
through the file, counting how many valid persons there are. Then,
we'll iterate through the file again, this time reading the valid
persons into a dynamically allocated array.
As usual, we recommend you use the " Incremental Build" software development
model. To encourage this use, we break down your
main()
requirements into steps. We suggest you throughly test each step before
moving to the next step.
Step 1: How many valid people are in the file?
- Create an integer called
validCount, and a pointer to
this integer. To receive full credit for this assignment, you must
ONLY access this variable for counting through the pointer to your
counting variable. (We know, kind of silly ... but the point is to
give you more pointer practice!)
- Create a Person object.
- Open the file PersonFile.dat,
a file that was created by 11-year old Emma Camp-Oberhauser. Until
the end of file, read each person within the file (using your
Person's
input() function), and test whether the Person
details read in are valid or not (using your Person's validate()
function). If valid, add one to validCount (via your
pointer to validCount).
- Take a moment to print the number of valid People in the file. It
should be an odd number, between 12 and 14.
Step 2: Add valid people to your new people array.
- Use dynamic memory to allocate an array of people on the heap that
is large enough to hold the number of valid people determined in Step
1. Do not over-allocate the array to hold all the people in the data
file.
- We now need to rewind the reading location of PersonFile.dat to the
beginning of the file. To do this, you could
close() the
file, and then re-open it; but doesn't that seem a bit foolish? Thus,
instead, use clear() and seekg(0,ios::beg)
functions on your input file stream. These two functions will clear
the 'end of file reached' and set the next position to read from
equal to the top of the file.
- Declare a new integer variable with initial value zero; this
variable will represent the current element offset inside your
dynamic array.
- In a loop (until the end of file):
- Read each person within the file (using your Person's
input()
function).
- Test whether the Person details read in are valid or not (using
your Person's
validate() function).
- If valid, assign that Person to the array (and increment your
new integer variable).
- If not valid, print that Person's details to the screen (using
your Person's
output() function).
There are exactly 19 invalid people in the data file. At this point you
will know by the program output whether you have found them all.
Step 3: Sorting your people array.
We now want to sort your valid people array. Lecture 25 discussed the
SelectionSort()
algorithm (a simple sorting algorithm), and provided brief pseudocode
for implementing it. A few more details are provided here. Put the function prototypes above
your
main()
and function implementations below. Create these prototypes and
function headers so that they operate on your People array, with the
end goal of sorting your valid People array by each person's height.
For full credit, you should pass a pointer to the array to your
SelectionSort()
function, and use this pointer within the function to access array
elements. However, we suggest you first implement the sorting feature
using the
[ ]
notation that you are familiar with, and then (if desired) modify the
function to use pointers (not
[ ]
). NOTE: getting the function to work with [ ] is worth
one point; getting the function to work with * is worth
two points.
Step 4: Print a few valid people.
Using your Person's
output()
function, print the following three valid people:
- the person with the smallest height (first element in your array)
- the person with the median height (the middle element in your
array; we've already confirmed that the number of elements is odd)
- the person with the largest height (last element in your array)
Step 5: Good practice.
There are two things you should do to end the program. First, close
your file input stream. Second, free the memory allocated by your
program to hold the valid people. Be sure to use the
delete[]
operation, not
delete
without
[]
.
Grading Rubric
Your final submission will be graded according to the following rubric.
| 10% |
Lab completed |
| 60% |
Assignment created with dynamic arrays and meets requirements above. |
| 30% |
(1) Comments used (2) Coding style followed
(3) Appropriate variable names, constants, and data types used (4)
Instructions followed (5) Assignment compiles |
Submission
Always, always, ALWAYS update the
header comments at the top of your main.cpp file. And if you ever get
stuck, remember that there is LOTS of help
available.
In summary, for homework due on
Monday, December 05 follow these specific steps:
- create a directory called week12.
- within week12, create two subdirectories: Lab12
and A12.
- within your new week12/Lab12 directory, copy in your main.cpp,
Bubble.h, Bubble.cpp files from your Lab12
solution.
- within your new week12/A12 directory, copy in your main.cpp,
Bubble.h, Bubble.cpp file and any other files you created/used
(*.h, *.cpp) from your A12 solution.
- compress the week12 directory (see Step 3 here for details).
- submit the week12.zip file to Blackboard (see Steps 5-10 here for details).
- after you submit, download the file and double check it
contains all that you think it contains!
This assignment is due
by December 09, 2016 08:00am.
| 