University of Liverpool
Department of Computer Science
COMP282 – Advanced Object-Oriented C Languages
Coursework 1 – C++
Deadline: Tuesday 13th April at 17:00
Weighting: 50%
Make sure your student ID is clearly shown in a comment at the top of your source code. Compress your
Visual Studio project into a single zip file and submit it via SAM. Penalties for late work will be applied in
accordance with the Code of Practice on Assessment.
Project Overview
You will create a small interactive program to
input details about people, manipulate them, and
display them. The project consists of several
tasks, which you should tackle in order. Each task
builds on the previous one. Do as much as you
can and then package your project for
submission. Begin by downloading the Visual
Studio project template for this assessment.
Read through this entire document before you
start coding, so you’re aware of all tasks and the
overall structure of the program. Your solution
should demonstrate your knowledge of C++.
Important: Each task requires you to add extra
code. You shouldn’t need to remove any code.
Keep the code from previous tasks in your
program so we can see it and mark it.
Important: Each part requires you to change the
code in the main() function, potentially losing the
previous version. Therefore we have provided
functions called main_part1(), main_part2() and
main_part3(). Place your code for each part
inside the relevant function. You can uncomment
the relevant lines in the real main() function to
run and test each part.
Part 1 (Worth 15%)
Task 1 – Person Class Definition (5%)
Create a Person class that stores a name and age. The name should be stored as a string, and the age as an
integer. Declare and define a constructor that takes appropriate parameters and stores them in the object.
Also declare and define a default constructor that sets the name to an empty string and the age to zero.
Task 2 – Person I/O (5%)
Implement the << and >> operators so you can output and input a Person object with the following string
format.
Jasmine 18
In other words, the name of the person is output followed by the age. When the user types a similar string
as input, the first token (up to the space) should be stored as the name, and the second (after the space) as
the age. For this task you do not need to do any input validation or error handling. Assume the user will
always type the correct format.
Task 3 – Comparison Operators (5%)
Implement comparison operators (<, >, and ==) for the Person class. These should work numerically, based
on the ages of the people involved.
Add relevant test code to the main_part1() function. Make sure it’s sufficient to test all the implemented
aspects of the Person class from all tasks so far.
Part 2 (Worth 45%)
Task 4 – Adding & Listing People (Fixed Storage) (20%)
Implement this and subsequent tasks in the main_part2() function. Create a loop to present menu items
and input user choices. At this stage the menu will only have three options.

  1. Add Person
  2. List Everyone
    Q. Quit
    You will need to use a suitable data structure to store Person objects. For the purposes of this task you can
    assume we will never want to store more than 9 people. An example run of this program is shown below.
    Example Output (Task 4)
  3. Add Person
  4. List Everyone
    Q. Quit
    Enter Option: 1
    Enter Details: Martin 42
  5. Add Person
  6. List Everyone
    Q. Quit
    Enter Option: 1
    Enter Details: Jenny 31
  7. Add Person
  8. List Everyone
    Q. Quit
    Enter Option: 2
    [1] Martin 42
    [2] Jenny 31
  9. Add Person
  10. List Everyone
    Q. Quit
    Enter Option: Q
    You should check that the storage is not full up (ie. already holds 9 people) before allowing a new person
    to be added. Display an error message if the user tries to add too many people.
    Task 5 – Finding the Oldest Person (10%)
    Add another menu option so the user can find the oldest person in the data structure. An example run is
    shown on the next page, assuming there is already some data in the system. You’ve already defined
    comparison operators for the Person class that should be useful in this task. The algorithm itself is fairly
    straightforward.
    Task 6 – Removing People (15%)
    Add another menu option so the user can remove people from the data structure. An example run is
    shown below, assuming there is already some data in the system.
    Example Output (Task 5)
  11. Add Person
  12. List Everyone
  13. Remove Person
  14. Find Oldest
    Q. Quit
    Enter Option: 2
    [1] Martin 42
    [2] Jenny 31
    [3] Alice 56
    [4] Freddie 18
  15. Add Person
  16. List Everyone
  17. Remove Person
  18. Find Oldest
    Q. Quit
    Enter Option: 4
    Oldest: Alice 56
  19. Add Person
  20. List Everyone
  21. Remove Person
  22. Find Oldest
    Q. Quit
    Enter Option: Q
    Example Output (Task 6)
  23. Add Person
  24. List Everyone
  25. Remove Person
  26. Find Oldest
    Q. Quit
    Enter Option: 2
    [1] Martin 42
    [2] Jenny 31
    [3] Alice 56
    [4] Freddie 18
  27. Add Person
  28. List Everyone
  29. Remove Person
  30. Find Oldest
    Q. Quit
    Enter Option: 3
    Enter Index: 2
  31. Add Person
  32. List Everyone
  33. Remove Person
  34. Find Oldest
    Q. Quit
    Enter Option: 2
    [1] Martin 42
    [2] Alice 56
    [3] Freddie 18
  35. Add Person
  36. List Everyone
  37. Remove Person
  38. Find Oldest
    Q. Quit
    Enter Option: Q
    You should make sure that you handle a situation where the user enters an index greater than the number
    of people in the data structure.
    You should shuffle data within the structure so there are no gaps when a user is removed. Remember you
    can refer back to lecture examples and similar code used during lab sessions. Note also that the index
    numbers in the output will reflect this shuffling of data, so they won’t always refer to the same person.
    Part 3 (Worth 40%)
    Task 7 – Refactored Program (Dynamic Data) (25%)
    Implement this and subsequent tasks in the main_part3() function. You might like to copy the code from
    the previous part as a starting point.
    Refactor the program so it uses a dynamic data structure. In other words, there is no limit on the number
    of people the program could store (assuming unlimited memory). The actual behaviour of the program
    won’t change from the user’s perspective, but internally it will be very different.
    You should use a dynamic data structure from the Standard Template Library, such as a vector. You should
    also use a corresponding STL iterator. Note that the vector class has an erase() function to remove items.
    Make full use of functions and algorithms from the STL where appropriate.
    Task 8 – Sorting the Data (15%)
    Add another menu option to sort the data in ascending order of age. Note that this will only sort the data,
    not display it. If the user wants to see the sorted list, they can select that option afterwards.
  39. Add Person
  40. List Everyone
  41. Remove Person
  42. Find Oldest
  43. Sort Data
    Q. Quit
    You should use the full range of functions and algorithms provided by the Standard Template Library, and
    implement any necessary helper functions, as explained in the relevant lecture material.
    How to Submit
    Locate your Visual Studio project folder and compress it into a single .zip archive. If you use any other
    format we won’t be able to extract and mark your work. Rename your archive so it has the module code
    and your student ID in the filename (eg. comp282_cw1_201212345.zip).
    If you want to draw our attention to anything, make a comment in the code itself. We will not read or mark
    any other documents.
    Submit your archive via SAM (https://sam.csc.liv.ac.uk/COM...). You can submit
    multiple attempts. If you submit more than one, we will only look at and mark the most recent.
    Marking Descriptors
    We draw your attention to the standard Department Grade Descriptors, which are listed in the Student
    Handbook.
    WX:codehelp
03-05 22:15