#include // for string type #include // basic I/O using namespace std; // Data Resources // // The next three arrays contain raw data about the items in a shop // The categories array holds the names of ten categories // The descriptions array holds the item description to the ten // items in each category. Hence it is a 10x10 table. // The prices array holds to each item its price per unit. // // For the two table structures, the first index is the category, // the second index is the position in the list. I call that: the code // // To complete the program, fill these structures with appropriate data // This may also come from a file or a database, I don't know. All I wanted // to achieve is that the menu items and all the logic can be automated by // associating with each category and code number a category name, item // description, and the item's unit price. string categories[10] = { "Meat and Poultry", "Fruits and Vegetables", "", "", "", "", "", "", "", "" }; string descriptions[10][10] = { { "Chicken 1kg (whole chicken)", "Chicken liver 500g", "", "", "", "", "", "", "", "" }, { "", "", "", "", "", "", "", "", "", "" }, { "", "", "", "", "", "", "", "", "", "" }, { "", "", "", "", "", "", "", "", "", "" }, { "", "", "", "", "", "", "", "", "", "" }, { "", "", "", "", "", "", "", "", "", "" }, { "", "", "", "", "", "", "", "", "", "" }, { "", "", "", "", "", "", "", "", "", "" }, { "", "", "", "", "", "", "", "", "", "" }, { "", "", "", "", "", "", "", "", "", "" } }; double prices[10][10] = { { 206.1, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }; // Central data structures // // The central data structure to work with is the Customer class. // It holds a shopping cart of type ShoppingCart (below), as well as // the customer's total credit she started out with. // The ShoppingCart class // // the ShoppingCart class is essentially a table, associating with each // category and item code number the number of units the customers has // ordered of this item. It is organised into a table, the first index is // the category, the second index is the item code number. The same numbers // that can be used to retrieve the price, item description, and category // title. // // This class provides basic access methods in the form of adding orders // and removing them again. class ShoppingCart { private: // set initial orders all to zero int orders_placed[10][10] = {0}; // Processes an order // // Depending on the sign of the quantity, a qunatitiy number of items // of the category 'category' and list position 'code' is added or // removed from the shopping cart. There is a safety check that removing // items can not turn the number of items in the cart below zero. // // @param category The category of the item // @param code The item's code number (list position) // @param quantity Number of units // @returns Only if more items are removed than there are in the cart, // the return value will be 'false'. In all other cases 'true'. bool process_order(int category, int code, int quantity) { // make sure there are enough orders placed if we remove if(orders_placed[category][code] + quantity >= 0) { orders_placed[category][code] += quantity; return true; } else return false; } public: // Wrapper method around 'process_order' for a positive quantity bool add_order(int category, int code, int quantity) { return process_order(category, code, quantity); } // Wrapper method around 'process_order' for a negative quantity bool remove_order(int category, int code, int quantity) { return process_order(category, code, -quantity); } // Calculates to total worth of the items in the cart // @returns The sum total of all items in the cart double sum_total() { double total = 0.0; // init to zero // walk through the entire orders_placed table and // sum up price * quantity. for(int cat = 0; cat < 10; cat++) { for(int code = 0; code < 10; code++) { total += orders_placed[cat][code] * prices[cat][code]; } } return total; // return the total worth of the cart's items } // Displays the contents of the shopping cart void display() { cout << "Your shopping cart:\n\n"; // a header // traverse the orders_placed table and print out // all categories and items that are within. Leave out categories // entirely if no items from the have been ordered. for(int cat = 0; cat < 10; cat++) { // find if there are items in that category bool process_category = false; for(int code = 0; code < 10; code++) { // if at least one item has been purchased, we want to display it // stop scanning the category at this point immediately if(orders_placed[cat][code] != 0) { process_category = true; break; } } // if there are items, display the contents if(process_category) { // display the category we're in cout << "Category " << cat + 1 << " - " << categories[cat] << "\n"; // For each item, if it's in the cart, display it! for(int code = 0; code < 10; code++) { if(orders_placed[cat][code] != 0) { cout << " " << code + 1 << ". " << descriptions[cat][code] << " : " << orders_placed[cat][code] << " items, totalling " << prices[cat][code] * orders_placed[cat][code] << endl; } } } } } }; // The Customer class // // A customer is a shopping cart and an amount of money. // This class has a few wrapper methods around the shopping cart, so that // we do not have to expose it, and one method that calculated the remaining // balance. class Customer { private: ShoppingCart cart; double debit; public: // Constructor // Injects the Shoppingcart dependency Customer(ShoppingCart cart, double debit) { this->cart = cart; this->debit = debit; } // Calculates the remaining balance double credit() { return debit - cart.sum_total(); // we cleverly use the shopping carts sum method } // Wrapper methods around the shopping cart void display_cart() { cart.display(); } bool add_order(int category, int code, int quantity) { return cart.add_order(category, code, quantity); } bool remove_order(int category, int code, int quantity) { return cart.remove_order(category, code, quantity); } }; // The nexts methods are the menu functions. // I have not worked these into a menu class because the original code used // a hybrid OOP and functions approach. // // The main_menu function presents the main menu, the choice of the categories // There are a few sanity checks, but very few. These need to be extended to check // that the menu item chosen is actually within a valid range and such things. // The main menu will loop the sub menu or cancel menu respectively. The looping is // controlled via the boolean return value of these functions. bool main_menu(Customer& customer); // the main menu (categories) bool sub_menu(int category, Customer& customer); // the sub menu (items) bool cancel_menu(Customer& customer); // the cancel menu (removing items) // Main driver function // Program entry point int main() { // init new customer Customer customer(ShoppingCart(), 5000000); bool loop = true; // Menu while(loop) { loop = main_menu(customer); } // main loop end cout << customer.credit() << endl; return 0; } // Menu function implementations // Runs the canellation menu // // In the canellation menu, a customer may remove items from the cart // // @param customer A reference to the customer // @returns 'false' if order is successfully canceled bool cancel_menu(Customer& customer) { // How it works: // We grab three data from the user: // 1) the category from which to remove // 2) the item code (list position) from which to remove // 3) the quantity to remove // // There are checks that the input is a number, but not more. // Removing items is left to the customer object. It delegates removal // of items to the cart within the customer object. If the removal fails, // the call will return false, if it succeeds, it will return true. The // return value of this function operates exactly the other way around! // So, we need to flip the result at the end... string str_input; // the raw user input as string int category; // captures the category number from the input int code; // captures the item code from the input int quantity; // captures the quantity from the input // Let's go! // Display items in the shopping cart customer.display_cart(); // you might want to add an exit option ... // Look at the other menu functions to get an idea of how to do that // Ask which category ... cout << "From which category do you wish to remove? "; getline(cin, str_input); // read entire line try { category = stoi(str_input) - 1; // try to convert to number } catch(const invalid_argument& ia) { return true; // in case of failure, loop this menu (= return true) } // ... which item number, and ... cout << "Which item number? "; getline(cin, str_input); // read entire line try { code = stoi(str_input) - 1; // try to convert to number } catch(const invalid_argument& ia) { return true; // in case of failure, loop this menu (= return true) } // ... the quantity to remove cout << "How many items do you wish to remove? "; getline(cin, str_input); // read entire line try { quantity = stoi(str_input); // try to convert to number } catch(const invalid_argument& ia) { return true; // in case of failure, loop this menu (= return true) } // if we got here, all inputs were numbers, and we can call into // customer items removal method. Flip the return value in the end! return !customer.remove_order(category, code, quantity); } // Run the sub-menu program // // The sub-menu program allows to chose a specific item after a category // has been chosen, or to return to the main menu. // // @param category The category for this sub-menu // @param customer The customer // @returns 'true' if this menu needs to loop, 'false' otherwise bool sub_menu(int category, Customer& customer) { string str_input; // raw user input as string int quantity; // captures the quantity from the input int code; // captures the item code from the input // Display sub-menu; walk through the descriptions array for // the given category from the parameter list for(int code = 0; code < 10; code++) { cout << code + 1 << ". " << descriptions[category][code] << "\n"; } cout << "x. Return to main menu\n"; // adds an 'exit' option cout << "Which item do you want to order? " << endl; // get input getline(cin, str_input); // read entire line try { code = stoi(str_input) - 1; // try to parse as number } catch(const invalid_argument &ia) { // if it is not a number, it might be the menu option 'x' to exit // We need to check that here, that the input length is not 0, to // prevent us accessing outside the bounds of the string! After that // check we can safely access the first letter and check if it is an 'x' if(str_input.size() == 1 && str_input[0] == 'x') return false; // do not loop this menu after 'exit' -> return false else return true; // otherwise it was invalid input, loop this menu // you might want to add some informative message for the user about // what went wrong with the input and why the menu is looped again } // If we reach this point, the conversion to a number went well. Hence // the user entered an item code (I do not check if it is within a valid // range though). That means the user wants to order something... cout << "How many ? "; getline(cin, str_input); // read entire line try { quantity = stoi(str_input); // try to parse as number } catch(const invalid_argument &ia) { return true; // input was not a number, loop the menu -> return true } // At this point, input was a number, so the user ordered some quantity // of the given item. We inform the user about the order just placed and // leave the menu with 'false' to return to the main menu. // Adding the order to the crt is handled by the cart itself, which is // an object in the customer object. cout << "You purchased " << quantity << " " << descriptions[category][code] << endl; customer.add_order(category, code, quantity); // Add the order to the cart return false; } // Run the Main Menu Program // // In the main menu, the user can choose a category from which she might want // to purchase something. there is also the option to exit the program, to // display the contents of the cart, or to remove items from the cart (cancel). // // @param customer The customer // @returns 'true' if this menu needs to loop, 'false' otherwise bool main_menu(Customer& customer) { string str_input; // raw user input as string int category; // captures the category from the input // Display menu; walk through the categories array for the titles for(int cat = 0; cat < 10; cat++) { cout << cat + 1 << ". " << categories[cat] << "\n"; } // you may want to add more options here like checkout, balance, etc... cout << "c. Cancel an order \n"; cout << "s. Shopping cart contents\n"; cout << "x. Exit" << endl; // process input getline(cin, str_input); // read entire line try { category = stoi(str_input) - 1; // try to parse as number } catch(const invalid_argument &ia) { // This runs, if input is not a number // Then it might be one of the letter menu options. // First we check that input is not empty, then we can safely access // the first char, being sure we're not outside the bounds of the input string if(str_input.size() == 1) { switch(str_input[0]) { // switch the possible menu options case 'c': while(cancel_menu(customer)); // loop the cancel menu return true; case 's': customer.display_cart(); // display the cart contents return true; case 'x': return false; // exit the main menu loop default: return true; // in all other cases, loop the menu } } // end if(str_input.size() == 1) else return true; // str_input size larger than a char? -> loop menu } // if we are here, user selected a number // run the sub_menu program ... while(sub_menu(category, customer)); return true; // ... and return to loop the main menu }

Shlee Shop Rework