COMP 2012 Assignment 1: Food Ordering System 29/03/2024, 23:23
COMP 2012 Object-Oriented Programming and Data
Structures
Assignment 1 Food Ordering System
Source: DALL-E
Introduction
In this assignment, we will combine the concepts of Object-Oriented Programming (OOP)
principles and utilizes C++ to construct a food ordering system. We will leverage the power
of OOP concepts like classes and objects to model real-world entities such as Order,
Buyer, and Menu. These classes will encapsulate relevant data and functionalities, ensuring
proper implementation. Additionally, we will employ basic C++ constructs like functions,
loops, and conditional statements to implement functionalities like adding items to
the menu, placing orders, and managing user interactions.
Furthermore, for this assignment you will work on these major functionalities.
Seller Actions
COMP 2012 Assignment 1: Food Ordering System 29/03/2024, 23:23
https://course.cse.ust.hk/comp2012/assignments/assignment1/#submission Page 2 of 19
View menu
Update menu
Add food item
Update food price
Remove food item
View orders
Process orders
Buyer Tasks
View menu
Place order
View my order
Copy an order
End of Introduction
Code overview
The following section describes the given classes and their purposes. You are given the
following files:
Buyer.h
Food.h
Menu.h
Order.h
OrderList.h
main.cpp
Now let's have a quick go through for each files that includes classes and function to create
a Food Ordering System.
Buyer Class (Buyer.h)
The file Buyer.h is a C++ header file defining a class named Buyer. The Buyer class
provides a way to create and manage buyer objects with their unique IDs and names. It
offers methods to access this information securely and modify it when necessary.
COMP 2012 Assignment 1: Food Ordering System 29/03/2024, 23:23
https://course.cse.ust.hk/comp2012/assignments/assignment1/#submission Page 3 of 19
class Buyer {
private:
 int buyerID;
 string buyerName;

public:
 //Default Constructor
 Buyer(int id = 0, const string& name = "");
 //Setter and getter methods for Buyer ID
 int getBuyerId() const;
 void setBuyerId(int newId);
 //Setter and getter methods for Buyer Name
 string getBuyerName() const;
 void setBuyerName(const string& newName);
};
Explanation of Buyer Class
The provided code defines a class named `Buyer` that represents a buyer in a system.
Member Variables
buyerID: An integer variable to store the unique identifier of the buyer.
buyerName: A string variable to store the name of the buyer.
Constructor
Buyer(int id = 0, const string& name = "")
This is the constructor for the `Buyer` class. It takes two optional arguments to initialize a
new `Buyer` object:
id (integer): An integer representing the buyer's ID (defaults to 0).
name (const string&): A constant string reference to the buyer's name (defaults
to an empty string).
Member Functions (Getters and Setters)
The `Buyer` class provides methods to access and modify its member variables in a
controlled manner:
getBuyerId() const: This function retrieves the current value of the `buyerID`
member variable and returns it as an integer. It's a **const** function, meaning it
guarantees not to modify the object's state.
setBuyerId(int newId): This function allows you to set a new value for the
`buyerID` member variable. It takes an integer argument (`newId`) representing the
new buyer ID.
getBuyerName() const: This function retrieves the current value of the
`buyerName` member variable and returns it as a string. Similar to `getBuyerId`, it's a
**const** function.
setBuyerName(const string& newName): This function allows you to set a new
value for the `buyerName` member variable. It takes a constant string reference
(`newName`) representing the buyer's new name.
COMP 2012 Assignment 1: Food Ordering System 29/03/2024, 23:23
https://course.cse.ust.hk/comp2012/assignments/assignment1/#submission Page 4 of 19
By using getters and setters, the `Buyer` class promotes data encapsulation. It restricts
direct access to the member variables and provides controlled ways to retrieve and update
their values.
Food Class (Food.h)
The file Food.h is a C++ header file defining a Food class. The Food class provides a
structured way to represent and manage food items with their unique IDs, names, and
prices. It offers methods to control access to these attributes and allows for creating deep
copies of existing food items.
class Food {
private:
 int foodID;
 string foodName;
 float price;
public:
 //Default Constructor
 Food(int id = 0, const string& name = "", float price = 0.0);

 // Copy constructor for Food
 Food(const Food& other);
 //Setter and getter method for Food ID
 void setFoodId(int newId);
 int getFoodId() const;

 //Setter and getter method for Food Name
 void setFoodName(const string& newName);
 string getFoodName() const;

 //Setter and getter method for Food Price
 void setPrice(float newPrice);
 float getPrice() const;

};
Explanation of Food Class
The provided code defines a class named `Food` that represents a food item within a
system.
Member Variables
foodID: An integer variable to store the unique identifier of the food item.
foodName: A string variable to store the name of the food item.
price: A float variable to store the price of the food item.
Constructors
The `Food` class includes two constructors for creating new `Food` objects:
Default Constructor:
Food(int id = 0, const string& name = "", float price = 0.0);
COMP 2012 Assignment 1: Food Ordering System 29/03/2024, 23:23
https://course.cse.ust.hk/comp2012/assignments/assignment1/#submission Page 5 of 19
This constructor takes three optional arguments for initializing a new `Food` object:
id (integer): An integer representing the food item's ID (defaults to 0).
name (const string&): A constant string reference to the food item's name
(defaults to an empty string).
price (float): A floating-point number representing the price of the food item
(defaults to 0.0).
Copy Constructor:
Food(const Food& other);
This constructor creates a deep copy of an existing `Food` object, ensuring
independent memory allocation for the copied data. While completing the copy
constructor task make sure you implement this as a delegated constructor.
Member Functions (Getters and Setters)
The `Food` class provides methods to access and modify its member variables:
getFoodId(): Returns the current value of the `foodID` member variable.
setFoodId(int newId): Sets a new value for the `foodID` member variable.
getFoodName(): Returns the current value of the `foodName` member variable.
setFoodName(const string& newName): Sets a new value for the `foodName`
member variable.
getPrice(): Returns the current value of the `price` member variable.
setPrice(float newPrice): Sets a new value for the `price` member variable.
Menu Class (Menu.h)
The file Menu.h is a C++ header file defining a Menu class. The Menu class provides a
structured way to manage a collection of food items within a menu system. It provides
functionalities to add, remove, display, and manage food items within a menu.
Explanation of Menu Class
class Menu {
private:
 Food* foodItems; // Dynamic array of food items
 int currentSize; // Current number of food items
 int capacity; // Maximum capacity of the array
 int nextFoodId; // Track the next available food item ID

public:
 Menu(); // Constructor to initialize currentSize and allocate memory for foodItems
 ~Menu(); // Destructor to free allocated memory
 void addFood(const Food& food);
 bool removeFood(int id);
 void displayMenu() const;
 void manageFoodItems();
 const Food* getFoodById(int id) const;
private: //Helper Functions
 bool isFull() const { return currentSize == capacity; }
 void resizeArray(); // Resizes the array if needed
 int findFoodIndex(int id) const;
};
COMP 2012 Assignment 1: Food Ordering System 29/03/2024, 23:23
https://course.cse.ust.hk/comp2012/assignments/assignment1/#submission Page 6 of 19
The provided code defines a class named `Menu` that represents a menu system for
managing food items.
Member Variables
foodItems: A pointer to a dynamic array of `Food` objects. This array stores the
actual food items included in the menu.
currentSize: An integer variable that keeps track of the current number of food
items stored in the `foodItems` array.
capacity: An integer variable that specifies the maximum number of food items the
`foodItems` array can hold.
nextFoodId: An integer variable that is used as a counter to track the next available
food item ID which should be a unique value. This variable is then used to assign new
Food item ID (a new and unique value) when added to menu.
Public Member Functions
Menu() (Constructor): This constructor initializes the `Menu` object. It sets
`currentSize` to 0, 'nextFoodId' to 1, and allocates memory for the `foodItems` array
with a chosen initial capacity. NOTE: Assign capacity value to 10 in the beginning.
~Menu() (Destructor): This destructor is responsible for freeing the memory allocated
for the `foodItems` array when a `Menu` object goes out of scope, preventing memory
leaks.
addFood(const Food& food): This function adds a new food item to the menu. It
takes a reference to a `Food` object (`food`) and adds it to the `foodItems` array.
removeFood(int id): This function removes a food item from the menu based on its
ID (`id`). It searches for the food item with the matching ID and removes it from the
`foodItems` array.
displayMenu() const: This function displays the information about all food items
currently in the menu. It iterates through the `foodItems` array and displays details of
each food item.
manageFoodItems(): This function provides an interface for managing food items in
the menu. It offer options to add, remove, edit, or perform other operations on the food
items.
getFoodById(int id) const: This function retrieves a pointer to a `Food` object
from the menu based on its ID (`id`). It searches for the food item with the matching ID
and returns a pointer to it, or `nullptr` if not found.
Private Helper Functions
isFull() const: This helper function checks if the `foodItems` array is at full
capacity. It returns `true` if the `currentSize` equals the `capacity`.
resizeArray(): This private function handles resizing the `foodItems` array if
needed. It called by `addFood` if the array is full, increasing the capacity and
reallocating memory for the array.
findFoodIndex(int id) const: This helper function searches for the index of a
food item with a specific ID (`id`) within the `foodItems` array. It iterates through the
array and returns the index if a match is found, or -1 if not found.
Order Class (Order.h)
The file Order.h is a C++ header file defining a Order class. The Order class provides a way
to represent and manage customer orders, including the ordered food items, buyer
information, and unique order ID. It offers functionalities to add items (with max size 10),
display order details, create order clones, and retrieve relevant information.
Menu
Introduction
Description
Resources & Sample
I/O
Submission &
Deadline
COMP 2012 Assignment 1: Food Ordering System 29/03/2024, 23:23
https://course.cse.ust.hk/comp2012/assignments/assignment1/#submission Page 7 of 19
Explanation of Order Class
The provided code defines a class named `Order` that represents a customer's order within
a system. It manages the details of the ordered items, buyer information, and order ID.
Member Variables
`orderId (private)`: This integer variable stores a unique identifier that distinguishes
each order within the system, ensuring no duplicate orders are created.
`currentNum (private)`: This integer variable tracks the current number of food items
included in the order, indicating the order's overall size.
`orderedItems (private)`: This array of `Food` objects, with a fixed capacity of 10,
stores the individual food items that have been added to the order. It acts as a central
repository for the order's contents. NOTE: DO NOT CHANGE THE ARRAY SIZE.
`buyer (private)`: This member variable holds an object of the `Buyer` class,
containing information about the customer who placed the order. This enables
association of orders with specific buyers.
Public Member Functions
Order() (Default Constructor): This function automatically initializes a new `Order`
object upon its creation. It will assign the 'orderId' and 'currentNum' value to 0.
addItem(const Food& item): This function is responsible for adding a new `Food`
item to the `orderedItems` array. It takes a reference to a `Food` object (`item`) as
input. However, it needs to manage the fixed size of the array, by returning a
success/failure indicator.
displayOrder() const: This function presents a visual summary of the order's
details, including the order ID, buyer information, and a list of the ordered food items
with their relevant details. It provides a clear readout of the order's contents.
cloneOrder(const Order& other): This function generates a self-contained copy
of another existing `Order` object (`other`). It involves replicating the `currentNum`,
and performing deep copies of the `orderedItems` array to ensure independent
memory storage.
getBuyer() const: This function grants read-only access to the `buyer` object
within the order, enabling retrieval of buyer information without the ability to modify the
class Order {
private:
 int orderId;
 int currentNum;
 Food orderedItems[10]; // Array to hold ordered food items (fixed size)
 Buyer buyer;
public:
 Order(); // Default Constructor
 bool addItem(const Food& item);
 void displayOrder() const;
 void cloneOrder(const Order& other);
 const Buyer& getBuyer() const;
 void setBuyer(int newBuyerId, string newBuyerName);
 int getcurrentNum() const;
 void setOrderId(int newId);
 int getOrderId() const;
};
Frequently Asked
Questions
Changelog
Page maintained by
USMAN Muhammad
Email: usman@ust.hk
Last Modified:
03/29/2024 11:50:38
Homepage
Course Homepage
COMP 2012 Assignment 1: Food Ordering System 29/03/2024, 23:23
https://course.cse.ust.hk/comp2012/assignments/assignment1/#submission Page 8 of 19
original object. It maintains data integrity.
getCurrentNum() const: This function reveals the current count of food items
within the order, providing insight into the order's size and contents.
setOrderId() const: Sets a new value for the `orderId` member variable.
getOrderId() const: This function returns the unique order ID, allowing for external
identification and tracking of specific orders within the system.
Order List Class (OrderList.h)
The file OrderList.h is a C++ header file defining a OrderList class. The OrderList class
provides a way to manage a collection of orders using a linked list. It offers functionalities to
add, remove, find, and display orders in the system.
Explanation of OrderList Class
The provided code defines a class named `OrderList` that manages a collection of `Order`
objects using a linked list data structure. It provides functionalities to add, remove, find,
display, and filter orders based on buyer ID.
Member Variables
**Private:**
head: A pointer to the first node (`OrderNode`) in the linked list. This serves as the
entry point for traversing the list.
Nested Struct: OrderNode
The `OrderList` class utilizes a private nested struct named `OrderNode`. This struct
defines the building block of the linked list, representing a single node that stores an `Order`
object and a pointer to the next node in the list.
order: An `Order` object, holding the details of a customer's order.
class OrderList {
public:
 OrderList();
 ~OrderList();

 void addOrder(const Order& order);
 bool removeOrder(int orderId);
 Order* findOrder(int orderId) const;
 void displayOrderList() const;
 void displayOrdersForBuyer(int buyerId) const;
 bool isEmpty() const;
private:
 struct OrderNode {
 Order order;
 OrderNode* next;
 const Buyer& buyer = order.getBuyer(); // Get a reference to the Buyer object
 OrderNode(const Order& order, OrderNode* next = nullptr) : order
 };
 OrderNode* head; // Pointer to the first node in the linked list
};
COMP 2012 Assignment 1: Food Ordering System 29/03/2024, 23:23
https://course.cse.ust.hk/comp2012/assignments/assignment1/#submission Page 9 of 19
next: A pointer to the next `OrderNode` in the linked list. It allows traversing the list by
following these pointers from node to node.
buyer (const Buyer&): A constant reference to the `Buyer` object associated with
the `order`. This reference is retrieved using the `getBuyer()` method of the `Order`
object within the node.
OrderNode(const Order& order, OrderNode* next = nullptr)
(Constructor): This constructor initializes a new `OrderNode` object. It takes an
`Order` object by reference (`order`) and an optional pointer to the next node (`next`).
It creates a new node storing the order and setting the `next` pointer accordingly
(defaults to `nullptr` if not provided).
Public Member Functions
OrderList() (Constructor): This constructor initializes the `OrderList` object. It set
the `head` pointer to `nullptr`, indicating an empty list.
~OrderList() (Destructor): This destructor is responsible for deallocating all the
nodes in the linked list when an `OrderList` object goes out of scope, preventing
memory leaks. It iterate through the list, starting from the `head`, and delete each
node appropriately, ensuring proper memory management.
addOrder(const Order& order): This function adds a new `Order` object to the
`OrderList`. It creates a new `OrderNode` with the provided `order` and inserts it at
the end of list.
removeOrder(int orderId): This function attempts to remove an order from the
list based on its unique ID (`orderId`). It searches for the node containing the matching
order and removes it from the linked list.
findOrder(int orderId) const: This function searches for an order in the list
based on its ID (`orderId`). It iterates through the linked list and returns a pointer to the
`Order` containing the matching order, or `nullptr` if not found.
displayOrderList() const: This function displays information about all orders
currently in the list. It iterates through the linked list and calls the `displayOrder`
function of each `OrderNode`'s `order` object to display details.
displayOrdersForBuyer(int buyerId) const: This function displays
information about orders placed by a specific buyer identified by their ID (`buyerId`). It
iterates through the list and checks the `buyer` reference within each `OrderNode`
using the `getBuyer().getId()` (assuming `Buyer` has a `getId` function) to see if it
matches the provided `buyerId`. If there's a match, the order details are displayed.
isEmpty() const: This function check if the order list is empty or not.
Main Class (main.cpp)
The main.cpp file already implemented for your use. Please don't make any changes in
main.cpp file. You are only required to complete other TODO tasks as shown in next
section.
End of Code overview
Description
This section describes your tasks in this assignment. You will need to finish 5 files:
1. Buyer.cpp
2. Food.cpp
3. Menu.cpp
4. Order.cpp
5. OrderList.cpp
These files may contain some functions that are already implemented for you. You should
not modify them, otherwise your submission may have unexpected behaviours in the
automatic grading system.
Assignment Tasks
COMP 2012 Assignment 1: Food Ordering System 29/03/2024, 23:23
https://course.cse.ust.hk/comp2012/assignments/assignment1/#submission Page 10 of 19
TODO 1
Complete the Buyer.cpp file. Here are the tasks list:
Task 1.1
Buyer::Buyer(int id, const string& name)
Complete the default constructor for buyer class.
Task 1.2
void Buyer::setBuyerId(int newId)
Complete setter method for Buyer Id. This function should assign the newId with current
buyer Id.
Task 1.3
int Buyer::getBuyerId() const
Complete getter method for Buyer Id. This function return the current buyer Id value.
Task 1.4
void Buyer::setBuyerName(const string& newName)
Complete setter method for Buyer Name. This function should assign the newName with
current buyer Name.
Task 1.5
string Buyer::getBuyerName() const
Complete getter method for Buyer Name. This function return the current buyer Name value.
TODO 2
Complete the Food.cpp file. Here are the tasks list:
Task 2.1
Food::Food(int id, const string& name, float price)
Complete the default constructor for Food class.
Task 2.2
Food::Food(const Food& other)
Complete the copy constructor for Food class. Copy constructor should be implemented
as a delegated constructor.
Task 2.3
void Food::setFoodId(int newId)
Complete setter method for Food Id. This function should assign the newId with current food
Id.
COMP 2012 Assignment 1: Food Ordering System 29/03/2024, 23:23
https://course.cse.ust.hk/comp2012/assignments/assignment1/#submission Page 11 of 19
Task 2.4
int Food::getFoodId() const
Complete getter method for Food Id. This function return the current food Id value.
Task 2.5
void Food::setFoodName(const string& newName)
Complete setter method for Food Name. This function should assign the newName with
current food name.
Task 2.6
string Food::getFoodName() const
Complete getter method for Food Name. This function return the current food Name value.
Task 2.7
void Food::setPrice(float newPrice)
Complete setter method for Food Price. This function should assign the newPrice with
current food price.
Task 2.8
float Food::getPrice() const
Complete getter method for Food Price. This function return the current food Price value.
TODO 3
Complete the Menu.cpp file. Here are the tasks list:
Task 3.1
Menu::Menu()
Complete the default constructor for Menu class.
Task 3.2
Menu::~Menu()
Complete the destructor for Food class.
Task 3.3
void Menu::addFood(const Food& food)
Complete addFood method for Menu class. This function adds a new food item to the menu.
It takes a reference to a Food object food and adds it to the foodItems array.
Task 3.4
bool Menu::removeFood(int id)
COMP 2012 Assignment 1: Food Ordering System 29/03/2024, 23:23
https://course.cse.ust.hk/comp2012/assignments/assignment1/#submission Page 12 of 19
Complete removeFood method for Menu class. This function removes a food item from the
menu based on its id. It searches for the food item with the matching ID and removes it from
the foodItems array.
Task 3.5
int Menu::findFoodIndex(int id) const
Complete findFoodIndex method for Menu class. This helper function searches for the
index of a food item with a specific id within the foodItems array. It iterates through the
array and returns the index if a match is found, or -1 if not found.
Task 3.6
const Food* Menu::getFoodById(int id) const
Complete getFoodById method for Menu class. This function retrieves a pointer to a Food
object from the menu based on its id. It searches for the food item with the matching ID and
returns a pointer to it, allowing access to its details.
Task 3.7
void Menu::resizeArray()
Complete resizeArray method for Menu class. This private function handles resizing the
foodItems array if needed. It called by addFood if the array is full, increasing the capacity
and reallocating memory for the array. NOTE: INCREASE THE CAPACITY BY 2 TIMES.
TODO 4
Complete the Order.cpp code file. Here are the tasks list:
Task 4.1
Order::Order()
Complete the default constructor for Order class.
Task 4.2
const Buyer& Order::getBuyer() const
Complete getBuyer method for Order class. This function grants read-only access to the
buyer object within the order, enabling retrieval of buyer information without the ability to
modify the original object. It maintains data integrity. In return this function should return a
buyer object.
Task 4.3
int Order::getcurrentNum() const
Complete getter method for currentNum variable. This function return the value of
currentNum variable.
Task 4.4
void Order::setOrderId(int newId)
COMP 2012 Assignment 1: Food Ordering System 29/03/2024, 23:23
https://course.cse.ust.hk/comp2012/assignments/assignment1/#submission Page 13 of 19
Complete setter method for Order Id. This function should assign the newId with current
order Id.
Task 4.5
int Order::getOrderId() const
Complete getter method for Order Id. This function return the current order Id value.
Task 4.6
void Order::setBuyer(int newBuyerId, string newBuyerName)
Complete setter method for Buyer Id and Buyer Name. This function should assign the
newBuyerId and newBuyerName with current buyer class variable by using it's setter
methods.
Task 4.7
bool Order::addItem(const Food& item)
Complete addItem method for Order class. This function is responsible for adding a new
Food item to the orderedItems array. It takes a reference to a Food object item as input.
Task 4.8
void Order::cloneOrder(const Order& other)
Complete cloneOrder method for Order class. This function generates a self-contained
copy of another existing Order object other. NOTE: THIS METHOD USE DEEP COPY
APPROACH.
TODO 5
Complete the OrderList.cpp file. Here are the tasks list:
Task 5.1
OrderList::OrderList()
Complete the default constructor for OrderList class.
Task 5.2
OrderList::~OrderList()
Complete the destructor for OrderList class. This destructor is responsible for deallocating
all the nodes in the linked list when an `OrderList` object goes out of scope, preventing
memory leaks.
Task 5.3
void OrderList::addOrder(const Order& order)
Complete addOrder method for OrderList class. This function adds a new Order object to
the OrderList. NOTE: MAKE SURE YOU INSERT NEW ORDER IN LIST AT THE END.
Task 5.4
COMP 2012 Assignment 1: Food Ordering System 29/03/2024, 23:23
https://course.cse.ust.hk/comp2012/assignments/assignment1/#submission Page 14 of 19
bool OrderList::removeOrder(int orderId)
Complete removeOrder method for OrderList class. This function attempts to remove an
order from the list based on its unique ID orderId.
Task 5.5
Order* OrderList::findOrder(int orderId) const
Complete findOrder method for OrderList class. This function searches for an order in the
list based on its ID orderId.
Task 5.6
bool OrderList::isEmpty() const
Complete isEmpty method for OrderList class. This function check if the order list is empty
or not.
Task 5.7
void OrderList::displayOrderList() const
Complete displayOrderList method for OrderList class. This function displays
information about all orders currently in the list.
Task 5.8
void OrderList::displayOrdersForBuyer(int buyerId) const
Complete displayOrdersForBuyer method for OrderList class. This function displays
information about orders placed by a specific buyer identified by their ID buyerId
End of Description
Resources & Sample I/O
Skeleton code: skeleton.zip
Demo program (executable for Windows): PA1.exe (Last updated 11:48 AM March
29)
End of Download
COMP 2012 Assignment 1: Food Ordering System 29/03/2024, 23:23
https://course.cse.ust.hk/comp2012/assignments/assignment1/#submission Page 15 of 19
Test Cases
Testing main: main_test.zip (Last updated 05:12 PM March 16)
main_test.cpp: Contains all the test cases to check your TODOs
make: Modified Make file to run the main_test.cpp
input: A folder contains all the input commands for main_test.cpp file
output: A folder contains all the expected output
To test your all .cpp files before submission you can test them using main_test.cpp file.
NOTE: While testing your code please use the given modified make file inside the
main_test.zip
Once you put all the files and folders into your main PA1 directory then you can run the
main_test.cpp file by typing the following command in terminal.
make test
When you execute the program, the prompt will ask you to input the TODOs number to test
from 1 to 5 and input the task number for each TODO. Alternatively, you can pass a text file
to the program as input:
./PA1_test.exe < input/inputX.txt
NOTE: Change the value of X in range from 1-21 to get the output for desired test case.
Then compare your results with respective given output results inside output/outputX.txt
Note: If your machine cannot run the files/commands above, you may consider using one of
the CS Lab machines. For more details please refer to Lab1 and Lab 3 tutorials
End of Test Cases
Submission and Deadline
Deadline: 23:59:00 on Saturday, March 30, 2024.
ZINC Submission
Create a single zip file that contains Buyer.cpp, Food.cpp, Menu.cpp, Order.cpp, and
OrderList.cpp files. Zip only these files, NOT a folder containing them. Submit the zip file to
ZINC. ZINC usage instructions can be found here.
Notes:
You may submit your file multiple times, but only the latest version will be graded.
Submit early to avoid any last-minute problem. Only ZINC submissions will be
accepted.
The ZINC server will be very busy in the last day especially in the last few hours, so you
should expect you would get the grading result report not-very-quickly. However, as
long as your submission is successful, we would grade your latest submission with all
test cases after the deadline.
If you have encountered any server-side problem or webpage glitches with ZINC, you
COMP 2012 Assignment 1: Food Ordering System 29/03/2024, 23:23
https://course.cse.ust.hk/comp2012/assignments/assignment1/#submission Page 16 of 19
may post on the ZINC support forum to get attention and help from the ZINC team
quickly and directly. If you post on Piazza, you may not get the fastest response as we
need to forward your report to them, and then forward their reply to you, etc.
NOTE: The program is compiled using the -fsanitize flag. You will lose points if your
program contains memory leak or other runtime issues.
Compilation Requirement
IMPORTANT: You are strongly recommended to finish the function prototypes such that the
program can compile before you start implementing the functions. If your program cannot
compile, your score on ZINC is automatically 0. If your program can compile, you may get
partial credits for tasks you have finished.
It is required that your submissions can be compiled and run successfully in our online
autograder ZINC. If we cannot even compile your work, it won't be graded. Therefore, for
parts that you cannot finish, just put in dummy implementation so that your whole program
can be compiled for ZINC to grade the other parts that you have done. Empty
implementations can be like:
Reminders
Make sure you actually upload the correct version of your source files - we only grade
what you upload. Some students in the past submitted an empty file or a wrong file or an
exe file which is worth zero mark. So you must double-check the file you have submitted.
Late Submission Policy
There will be a penalty of -1 point (out of a maximum 100 points) for every minute you are
late. For instance, since the deadline of assignment 1 is 23:59:00 on March 30th, if you
submit your solution at 1:00:00 on March 31st , there will be a penalty of -61 points for your
assignment. However, the lowest grade you may get from an assignment is zero: any
negative score after the deduction due to late penalty (and any other penalties) will be reset
to zero.
End of Submission and Deadline
int SomeClass::SomeFunctionICannotFinishRightNow()
{
 return 0;
}
void SomeClass::SomeFunctionICannotFinishRightNowButIWantOtherPartsGraded()
{
}
COMP 2012 Assignment 1: Food Ordering System 29/03/2024, 23:23
https://course.cse.ust.hk/comp2012/assignments/assignment1/#submission Page 17 of 19
Frequently Asked Questions
Frequently Asked Questions
Q: My code doesn't work / there is an error. Here is the code. Can you help me fix it?
A: As the assignment is a major course assessment, to be fair, you are supposed to work on
it on your own, and we should not finish the tasks for you. We might provide some very
general hints, but we shall not fix the problem or debug it for you.
Q: Can I include additional libraries?
A: No, other than the libraries already included in their respective .cpp files.
Q: Can I use global or static variables such as static int x?
A: No.
Q: Can I use auto?
A: No.
Q: What is the purpose of nextFoodId variable in menu class?
A: Refer to Piazza disscussion @149 and also @144 and their followup discussions.
End of Frequently Asked Questions
Changelog
11:48 AM 29/03/2024: Updated the demo program PA1.exe using the updated menu.cpp
file.
07:51 PM 24/03/2024: Updated the description of cloneOrder(const Order& other)
function.
12:39 PM 20/03/2024: Assignment due date is changed from 26th March to 30th March.
10:57 AM 18/03/2024: Skeleton code file Menu.cpp is revised. In Menu.cpp file in the given
function void Menu::manageFoodItems() please update only the case 1:
COMP 2012 Assignment 1: Food Ordering System 29/03/2024, 23:23
https://course.cse.ust.hk/comp2012/assignments/assignment1/#submission Page 18 of 19
is changed to
10:57 AM 18/03/2024: Skeleton code zip file is now updated with the new Menu.cpp file.
01:57 AM 17/03/2024: In OrderList class description findOrder(int orderId)
const function detail is updated. Furthermore, In Menu class description nextFoodId
variable and getFoodById(int id) const function details are updated.
01:26 AM 17/03/2024: In Order class description, more details on Order() and
cloneOrder(const Order& other) is added for further clarification.
case 1: {
 cout << "Current Menu items: "<< endl;
 displayMenu();
 if (isFull()) {
 cout << "Menu is full. Cannot add more food items."
 return;
 }
 // Get user input for food details
 string name;
 float price; // Ensure this is float to match the constructor
 cout << "Enter food name: ";
 cin >> name;
 cout << "Enter food price: ";
 cin >> price;
 Food newFood(nextFoodId, name, price); // Use nextFoodId here
 addFood(newFood);
 cout << "Food item added successfully." << endl;
 break;
 }
case 1: {
 cout << "Current Menu items: "<< endl;
 displayMenu();
 // Get user input for food details
 string name;
 float price; // Ensure this is float to match the constructor
 cout << "Enter food name: ";
 cin >> name;
 cout << "Enter food price: ";
 cin >> price;
 Food newFood(nextFoodId, name, price); // Use nextFoodId here
 addFood(newFood);
 cout << "Food item added successfully." << endl;
 break;
 }
COMP 2012 Assignment 1: Food Ordering System 29/03/2024, 23:23
https://course.cse.ust.hk/comp2012/assignments/assignment1/#submission Page 19 of 19
Maintained by COMP 2012 Teaching Team © 2024 HKUST Computer Science and Engineering
06:14 PM 16/03/2024: Test Cases section is updated. ZINC submission is also available
now.
05:58 AM 14/03/2024: Removed the OrderList class helper function, cleatList()
from OrderList.h file. Where this functionality needs to be implement in OrderList class
destructor. Please download the lastest skeleton file.
06:22 AM 14/03/2024: Updated the definition of Menu() constructor in Menu class and
请加QQ：99515681  邮箱：99515681@qq.com   WX：codehelp