关于后端:CS-215-链表

CS 215 – Winter 2019
Project 3/4
Learning Objectives:

• Implementation of a program using Object Oriented Design.
• Implementation of lists using Dynamically-Allocated Linked Lists.
  General Description:
  You are to write a program that implements score keeping for a league of sports teams. The league
  consists of a list of teams that are members of the league, and a list of games/matches.
  Team data and initial game data are read from text files. Using menu options, the user may view various
  parts of the data, and may add new games to the data. The game data is then written to a text file on
  exit from the program.
  The program presents the user with the menu as
  shown here, starting with a logo that contains the
  program name and the name of the programmer.
  The menu option entered by the user is validated
  until a valid menu option is entered. Only the first
  character of the user’s input is recognized, and that
  character is treated as not case sensitive. After
  performance of a valid option, the menu repeats
  until the exit option is selected.
  List all teams:
  A list of all teams read from the input file is printed
  using the format shown in the example. The header
  line includes the total number of teams in
  parenthesis. Field widths include:
• Team Id 4
• Team Name 25
• Coach 20
  with two spaces between columns. No system pause
  is needed after the list is printed.
  List all games:
  A list of all games read from the input file and entered by the
  user is printed using the format shown in the example. The
  header line includes the total number of teams in
  parenthesis. The field widths include:
• Date 10 (left justified)
• Team Ids 4 (left justified)
• Scores 3 (right justified)
  with two spaces between columns. Note that the winning
  team is listed first on each line. After the last game is printed,
  a blank line is followed by a system pause.
  2
  Query Team:
  First, the list of teams is printed, exactly as in print all teams above.
  Next, the user is asked to enter the Team Id of the selected team. The user’s input is validated to be a
  valid Team Id, repeating until a valid
  value is entered.
  A report of the selected team is printed
  as shown in the example. It includes
  the number of games won and lost by
  the team, based on counts taken from
  the game data.
  Finally, the game list is printed,
  formatted exactly as described above
  for print all teams. Note that both
  games lost (team data in the right
  columns) and games won (team data in
  the center columns) are printed.
  Add Game:
  First, the list of all teams is printed exactly as described above for print all teams.
  The user is then asked to enter the Team Id for the first team. This is validated/repeated exactly as
  described for Query Team. The Team Id
  for the second team is entered/validated.
  Next, the points for the two teams and
  the date of the game are entered. There is
  no validation for these three values, and it
  is assumed the user will enter integers for
  scores, and a string with no spaces in the
  correct date format for the date.
  Once all data is entered, and the game data added to the internal list, the program prints“Game
  added”. Note the program may have to“swap”team 1 with team 2 when adding the game, depending
  on the higher score (since the winning team should be stored as team 1).
  Exit:
  The program should write the current game data to an
  output file called“games2.txt”, then do a system
  pause before ending the program.
  3
  Detailed Design:
  The program should be designed and implemented using Object Oriented Programming. All lists should
  be implemented as Dynamically-Allocated Linked Lists.
  main program:
  Write a free function called doAbort() that is given an error message (string). It prints the error message
  on the screen, followed by a newline; does a system pause; and ends the program with exit(1); For any
  .cpp in the project that needs to invoke this free function, place its prototype at the top of the .cpp file.
  The main program should declare a league class and invoke the go() method. This should be followed by
  the standard system pause and return 0;
  The classes consist of the following:
  team
  A team consists of the following data:
• Team Id (assumed to be length 4 or less with no spaces)
• Name (assumed to be length 25 or less and may have spaces)
• Coach (assumed to be length 20 or less and may have spaces)
• next (pointer to the next team object in a linked list of teams)
  Standard set and get methods should be coded for the Team Id, Name and Coach (probably not needed
  for the next pointer, but those may be added if needed).
  Write a standard constructor (pointers are usually set to NULL in constructors).
  You may declare the team list class to be a friend, but no other classes or free functions should be
  declared as friends.
  team list
  The team list is a dynamic linked list of team objects. The only data needed is a head pointer for the
  linked list (optional: a tail pointer). The constructor should set the head (and tail) to NULL.
  The methods that should be implemented include:
  addTeam: given a new team object
  Dynamically allocates a new team object and copies the data from the given object into the
  dynamic object. It should then add the new object to the front (head) of the linked list.
  4
  readData:
  Reads data from a file called“teams.txt”and adds them to the linked list.
  The format of the input file is, for each team:
• first line: the Team Id, a string with no spaces
• second line: the Team Name, a string with spaces
• third line: the Coach, a string with spaces
  –
  There is no“number of teams”nor a Sentinel value at the end of the data. Instead use the .eof()
  method of an ifstream to detect end of file. Ex: while(!f.eof()) {…}
  A sample input file is provided on the course website. Here is one with two teams:
  UK
  Kentucky Wildcats
  Calipari
  LOU
  Louisville Cardinals
  Job Open
  printTeams:
  Prints the team list report as described above, based on data currently in the linked list of
  teams.
  getTeamRef: given: a Team Id
  returns: a pointer to a team, or NULL
  Searches the current linked list for a team object that has a matching Team Id member. When
  found, return the pointer to the team object found; otherwise, return NULL for“not found”.
  getNumTeams: returns: the number of teams in the list.
  Count and return the number of nodes in the list, which may be 0.
  game: game objects will be part of a linked list (gameList) and will also point to objects in the Team List
  A game consists of the following data for a game played between two teams:
• date a string assumed to be in YYYY/MM/DD format (length 10)
• points scored(2) points scored by team 1 and team 2
• team pointer (2) a pointer to a team in the teamList list for team 1 and team 2
• next a pointer to a game, the next game in the list or NULL
  The class may make class gameList a friend, but no other classes or functions.
  Constructor: standard constructor initializing all members of the object.
  set: one set method given a date, two team pointers, and two scores.
  alternative: one set method for each member (except next)
  gets: one get for each member, except next.
  5
  gameList: this is a Linked List of game objects, including a head and tail pointer.
  data and constructor
  head – a pointer to a game object, the first in the list
  tail – a pointer to a game object, the last in the list
  constructor – simply sets the two pointers to NULL.
  addGame – given a game object.
• dynamically allocates a new game object
• copies the data members from the given object into the newly allocated object
• inserts the newly allocated object into the game list at the tail of the list.
  readGames: – given a Team List Object.
  This method reads game data from a file called“games.txt”(validate the file opens, and
  close at the end) and creates the initial game list.
  The format of the game input file is: each line contains data on one game in the following order:
  DATE TEAM ID 1 POINTS FOR TEAM 1 TEAM ID2 POINTS FOR TEAM 2
  There is no“number of games”at the top of file, and there is no sentinel value/record at the
  end of the file. Use eof() to detect the end of file. A sample data file is provided on the course
  website.
  The method should read data into a local game object. It will have to“look up”a pointer to each
  team using the Team List Object passed in. It should invoke addGame on the populated game
  object to add a new game to the list.
  This function invokes the global free function (declared in main() and prototyped in this .cpp file)
  abort() when:
• the file fails to open
  “gameList::readGames: unable to open games.txt”
• the Team Id read is not found in the given Team List for either team:
  “gameList::read: invalid team id 1/2 = ” + teamIdReadFromFile
  getNumGames – counts and returns the number of games in the entire list.
  getNumWins – given a pointer to a team object, searches the list and counts/returns the number of
  games won by the team pointed to by the given pointer.
  getNumLosses – given a pointer to a team object, searches the list and counts/returns the number of
  games lost by the team pointed to by the given pointer.
  6
  printGames – given a pointer to a team object
• when the given pointer is NULL, prints all games in the list.
  (See List all games example above).
• when the given pointer is NOT NULL, prints all games in the list where the given pointer points
  to the same team object as“team pointer 1”or“team pointer 2”in the list.
  (See Query Team example above).
• Print a“header”as shown in the examples above, including the number of teams in a dashed
  line for the first line (invoke getNumGames()). Put two blanks between each column. Assume
  the max lengths on the data values are:
  o date: 10
  o points: 3
  o team Id 4
  writeGames –
  Writes the current game data to a text file called“games2.txt”, in the same format as the input
  file described in readGames above. The method should use the two team pointers for each
  game to retrieve the Team Id for each.
  league: this represents our whole application. Main simply declares a league object and invokes its go().
  Most of the methods have been written for you (posted on the course website). Similar to your lab 8,
  complete the methods where there are // TO DO: comment tags in the code.
  All methods are private except go()!
  Data and constructors
• a team list object
• a game list object
• constructor: since both members have their own constructors, a constructor is not needed.
  askTeamId – given: a (string) prompt that is assumed to be like“Enter team id …”
  returns: a pointer to the team found.
  This method prints the prompt and allows the user to enter a Team Id (assume no spaces). It
  searches the Team List for the team Id entered. When found, it returns the team Id pointer. When
  not found, it repeats the question (prompt) until the user enters a valid team Id. See Query Team in
  the specifications above.
  addGame –
  This method prints the team list, invokes askTeamId() twice to get the team pointers for two teams,
  asks for the points for the two teams and the date of the game. It populates a local game object
  then invokes addGame in the game list to add a new game to the list.
  7
  queryTeam –
  This method first prints the team list. It invokes askTeamId to get a pointer to the team to look up. It
  uses the get() methods from the team class to print the data from the found team object. Finally, it
  prints all games for the team by invoking printGames() giving it the found team pointer. See Query
  Team above for the format of the output.
  getMenuOption – returns the user’s selected menu option. This is written for you.
  go()
  This is the“main”of the application. It starts by invoking the reads in both the team list and game
  list objects. This is followed by the main menu control loop for the application.
  Submission:
  zip the following files into a .zip file, and submit the .zip in Canvas:
• game.h, game.cpp
• gameList.h, gameList.cpp
• team.h, team.cpp
• teamList.h, teamList.cpp
• league.h, league.cpp
• proj3/main.cpp
  There is no need to include data files (.txt)